remove int type file

deps/SZ/sz/include/sz_double.h

@@ -21,37 +21,18 @@ void computeReqLength_double(double realPrecision, short radExpo, int* reqLength
 short computeReqLength_double_MSST19(double realPrecision);
 
 unsigned int optimize_intervals_double_1D(double *oriData, size_t dataLength, double realPrecision);
-unsigned int optimize_intervals_double_2D(double *oriData, size_t r1, size_t r2, double realPrecision);
-unsigned int optimize_intervals_double_3D(double *oriData, size_t r1, size_t r2, size_t r3, double realPrecision);
-unsigned int optimize_intervals_double_4D(double *oriData, size_t r1, size_t r2, size_t r3, size_t r4, double realPrecision);
 
-unsigned int optimize_intervals_double_3D_opt(double *oriData, size_t r1, size_t r2, size_t r3, double realPrecision);
-unsigned int optimize_intervals_double_2D_opt(double *oriData, size_t r1, size_t r2, double realPrecision);
 unsigned int optimize_intervals_double_1D_opt(double *oriData, size_t dataLength, double realPrecision);
 
-size_t SZ_compress_double_3D_MDQ_RA_block(double * block_ori_data, double * mean, size_t dim_0, size_t dim_1, size_t dim_2, size_t block_dim_0, size_t block_dim_1, size_t block_dim_2, double realPrecision, double * P0, double * P1, int * type, double * unpredictable_data);
 
 unsigned int optimize_intervals_double_1D_opt_MSST19(double *oriData, size_t dataLength, double realPrecision);
-unsigned int optimize_intervals_double_2D_opt_MSST19(double *oriData, size_t r1, size_t r2, double realPrecision);
-unsigned int optimize_intervals_double_3D_opt_MSST19(double *oriData, size_t r1, size_t r2, size_t r3, double realPrecision);
 TightDataPointStorageD* SZ_compress_double_1D_MDQ(double *oriData, 
 size_t dataLength, double realPrecision, double valueRangeSize, double medianValue_d);
 void SZ_compress_args_double_StoreOriData(double* oriData, size_t dataLength, unsigned char** newByteData, size_t *outSize);
 
 char SZ_compress_args_double_NoCkRngeNoGzip_1D(int cmprType, unsigned char** newByteData, double *oriData, size_t dataLength, double realPrecision, size_t *outSize, double valueRangeSize, double medianValue_d);
 
-TightDataPointStorageD* SZ_compress_double_2D_MDQ(double *oriData, size_t r1, size_t r2, double realPrecision, double valueRangeSize, double medianValue_d);
-char SZ_compress_args_double_NoCkRngeNoGzip_2D(int cmprType, unsigned char** newByteData, double *oriData, size_t r1, size_t r2, double realPrecision, size_t *outSize, double valueRangeSize, double medianValue_d);
-
-TightDataPointStorageD* SZ_compress_double_3D_MDQ(double *oriData, size_t r1, size_t r2, size_t r3, double realPrecision, double valueRangeSize, double medianValue_d);
-char SZ_compress_args_double_NoCkRngeNoGzip_3D(int cmprType, unsigned char** newByteData, double *oriData, size_t r1, size_t r2, size_t r3, double realPrecision, size_t *outSize, double valueRangeSize, double medianValue_d);
-
-TightDataPointStorageD* SZ_compress_double_4D_MDQ(double *oriData, size_t r1, size_t r2, size_t r3, size_t r4, double realPrecision, double valueRangeSize, double medianValue_d);
-char SZ_compress_args_double_NoCkRngeNoGzip_4D(unsigned char** newByteData, double *oriData, size_t r1, size_t r2, size_t r3, size_t r4, double realPrecision, size_t *outSize, double valueRangeSize, double medianValue_d);
-
 TightDataPointStorageD* SZ_compress_double_1D_MDQ_MSST19(double *oriData, size_t dataLength, double realPrecision, double valueRangeSize, double medianValue_f);
-TightDataPointStorageD* SZ_compress_double_2D_MDQ_MSST19(double *oriData, size_t r1, size_t r2, double realPrecision, double valueRangeSize, double medianValue_f);
-TightDataPointStorageD* SZ_compress_double_3D_MDQ_MSST19(double *oriData, size_t r1, size_t r2, size_t r3, double realPrecision, double valueRangeSize, double medianValue_f);
 
 void SZ_compress_args_double_withinRange(unsigned char** newByteData, double *oriData, size_t dataLength, size_t *outSize);
 
@@ -65,31 +46,11 @@ int errBoundMode, double absErr_Bound, double relBoundRatio, double pwRelBoundRa
 
 void SZ_compress_args_double_NoCkRnge_1D_subblock(unsigned char* compressedBytes, double *oriData, double realPrecision, size_t *outSize, double valueRangeSize, double medianValue_d,
 size_t r1, size_t s1, size_t e1);
-void SZ_compress_args_double_NoCkRnge_2D_subblock(unsigned char* compressedBytes, double *oriData, double realPrecision, size_t *outSize, double valueRangeSize, double medianValue_d,
-size_t r2, size_t r1, size_t s2, size_t s1, size_t e2, size_t e1);
-void SZ_compress_args_double_NoCkRnge_3D_subblock(unsigned char* compressedBytes, double *oriData, double realPrecision, size_t *outSize, double valueRangeSize, double medianValue_d,
-size_t r3, size_t r2, size_t r1, size_t s3, size_t s2, size_t s1, size_t e3, size_t e2, size_t e1);
-void SZ_compress_args_double_NoCkRnge_4D_subblock(unsigned char* compressedBytes, double *oriData, double realPrecision, size_t *outSize, double valueRangeSize, double medianValue_d,
-size_t r4, size_t r3, size_t r2, size_t r1, size_t s4, size_t s3, size_t s2, size_t s1, size_t e4, size_t e3, size_t e2, size_t e1);
 
 unsigned int optimize_intervals_double_1D_subblock(double *oriData, double realPrecision, size_t r1, size_t s1, size_t e1);
-unsigned int optimize_intervals_double_2D_subblock(double *oriData, double realPrecision, size_t r1, size_t r2, size_t s1, size_t s2, size_t e1, size_t e2);
-unsigned int optimize_intervals_double_3D_subblock(double *oriData, double realPrecision, size_t r1, size_t r2, size_t r3, size_t s1, size_t s2, size_t s3, size_t e1, size_t e2, size_t e3);
-unsigned int optimize_intervals_double_4D_subblock(double *oriData, double realPrecision, size_t r1, size_t r2, size_t r3, size_t r4, size_t s1, size_t s2, size_t s3, size_t s4, size_t e1, size_t e2, size_t e3, size_t e4);
 
 TightDataPointStorageD* SZ_compress_double_1D_MDQ_subblock(double *oriData, double realPrecision, double valueRangeSize, double medianValue_d,
 size_t r1, size_t s1, size_t e1);
-TightDataPointStorageD* SZ_compress_double_2D_MDQ_subblock(double *oriData, double realPrecision, double valueRangeSize, double medianValue_d,
-size_t r1, size_t r2, size_t s1, size_t s2, size_t e1, size_t e2);
-TightDataPointStorageD* SZ_compress_double_3D_MDQ_subblock(double *oriData, double realPrecision, double valueRangeSize, double medianValue_d,
-size_t r1, size_t r2, size_t r3, size_t s1, size_t s2, size_t s3, size_t e1, size_t e2, size_t e3);
-TightDataPointStorageD* SZ_compress_double_4D_MDQ_subblock(double *oriData, double realPrecision, double valueRangeSize, double medianValue_d,
-size_t r1, size_t r2, size_t r3, size_t r4, size_t s1, size_t s2, size_t s3, size_t s4, size_t e1, size_t e2, size_t e3, size_t e4);
-
-unsigned int optimize_intervals_double_2D_with_freq_and_dense_pos(double *oriData, size_t r1, size_t r2, double realPrecision, double * dense_pos, double * max_freq, double * mean_freq);
-unsigned int optimize_intervals_double_3D_with_freq_and_dense_pos(double *oriData, size_t r1, size_t r2, size_t r3, double realPrecision, double * dense_pos, double * max_freq, double * mean_freq);
-unsigned char * SZ_compress_double_2D_MDQ_nonblocked_with_blocked_regression(double *oriData, size_t r1, size_t r2, double realPrecision, size_t * comp_size);
-unsigned char * SZ_compress_double_3D_MDQ_nonblocked_with_blocked_regression(double *oriData, size_t r1, size_t r2, size_t r3, double realPrecision, size_t * comp_size);
 
 
 #ifdef __cplusplus

deps/SZ/sz/include/sz_double_pwr.h

@@ -19,18 +19,7 @@ extern "C" {
 
 void compute_segment_precisions_double_1D(double *oriData, size_t dataLength, double* pwrErrBound, unsigned char* pwrErrBoundBytes, double globalPrecision);
 unsigned int optimize_intervals_double_1D_pwr(double *oriData, size_t dataLength, double* pwrErrBound); 
-void compute_segment_precisions_double_2D(double *oriData, double* pwrErrBound, 
-size_t r1, size_t r2, size_t R2, size_t edgeSize, unsigned char* pwrErrBoundBytes, double Min, double Max, double globalPrecision);
-unsigned int optimize_intervals_double_2D_pwr(double *oriData, size_t r1, size_t r2, size_t R2, size_t edgeSize, double* pwrErrBound);
-void compute_segment_precisions_double_3D(double *oriData, double* pwrErrBound, 
-size_t r1, size_t r2, size_t r3, size_t R2, size_t R3, size_t edgeSize, unsigned char* pwrErrBoundBytes, double Min, double Max, double globalPrecision);
-unsigned int optimize_intervals_double_3D_pwr(double *oriData, size_t r1, size_t r2, size_t r3, size_t R2, size_t R3, size_t edgeSize, double* pwrErrBound);
 void SZ_compress_args_double_NoCkRngeNoGzip_1D_pwr(unsigned char** newByteData, double *oriData, double globalPrecision, size_t dataLength, size_t *outSize, double min, double max);
-void SZ_compress_args_double_NoCkRngeNoGzip_2D_pwr(unsigned char** newByteData, double *oriData, double globalPrecision, size_t r1, size_t r2,
-size_t *outSize, double min, double max);
-void SZ_compress_args_double_NoCkRngeNoGzip_3D_pwr(unsigned char** newByteData, double *oriData, double globalPrecision, 
-size_t r1, size_t r2, size_t r3, size_t *outSize, double min, double max);
-
 void createRangeGroups_double(double** posGroups, double** negGroups, int** posFlags, int** negFlags);
 void compressGroupIDArray_double(char* groupID, TightDataPointStorageD* tdps);
 TightDataPointStorageD* SZ_compress_double_1D_MDQ_pwrGroup(double* oriData, size_t dataLength, int errBoundMode, 
@@ -39,15 +28,9 @@ void SZ_compress_args_double_NoCkRngeNoGzip_1D_pwrgroup(unsigned char** newByteD
 size_t dataLength, double absErrBound, double relBoundRatio, double pwrErrRatio, double valueRangeSize, double medianValue_f, size_t *outSize);
 
 void SZ_compress_args_double_NoCkRngeNoGzip_1D_pwr_pre_log(unsigned char** newByteData, double *oriData, double globalPrecision, size_t dataLength, size_t *outSize, double min, double max);
-void SZ_compress_args_double_NoCkRngeNoGzip_2D_pwr_pre_log(unsigned char** newByteData, double *oriData, double globalPrecision, size_t r1, size_t r2, size_t *outSize, double min, double max);
-void SZ_compress_args_double_NoCkRngeNoGzip_3D_pwr_pre_log(unsigned char** newByteData, double *oriData, double globalPrecision, size_t r1, size_t r2, size_t r3, size_t *outSize, double min, double max);
 
 void SZ_compress_args_double_NoCkRngeNoGzip_1D_pwr_pre_log_MSST19(unsigned char** newByteData, double *oriData, double pwrErrRatio, size_t dataLength, size_t *outSize, double valueRangeSize, double medianValue_f,
 																unsigned char* signs, bool* positive, double min, double max, double nearZero);
-void SZ_compress_args_double_NoCkRngeNoGzip_2D_pwr_pre_log_MSST19(unsigned char** newByteData, double *oriData, double pwrErrRatio, size_t r1, size_t r2, size_t *outSize, double valueRangeSize,
-																unsigned char* signs, bool* positive, double min, double max, double nearZero);
-void SZ_compress_args_double_NoCkRngeNoGzip_3D_pwr_pre_log_MSST19(unsigned char** newByteData, double *oriData, double pwrErrRatio, size_t r1, size_t r2, size_t r3, size_t *outSize, double valueRangeSize, 
-																unsigned char* signs, bool* positive, double min, double max, double nearZero);
 
 #ifdef __cplusplus
 }

deps/SZ/sz/include/sz_float.h

@@ -20,20 +20,11 @@ void computeReqLength_float(double realPrecision, short radExpo, int* reqLength,
 short computeReqLength_float_MSST19(double realPrecision);
 
 unsigned int optimize_intervals_float_1D(float *oriData, size_t dataLength, double realPrecision);
-unsigned int optimize_intervals_float_2D(float *oriData, size_t r1, size_t r2, double realPrecision);
-unsigned int optimize_intervals_float_3D(float *oriData, size_t r1, size_t r2, size_t r3, double realPrecision);
-unsigned int optimize_intervals_float_4D(float *oriData, size_t r1, size_t r2, size_t r3, size_t r4, double realPrecision);
 
 unsigned int optimize_intervals_and_compute_dense_position_float_1D(float *oriData, size_t dataLength, double realPrecision, float * dense_pos);
-unsigned int optimize_intervals_and_compute_dense_position_float_3D(float *oriData, size_t r1, size_t r2, size_t r3, double realPrecision, float * dense_pos);
-unsigned int optimize_intervals_float_3D_with_freq_and_dense_pos(float *oriData, size_t r1, size_t r2, size_t r3, double realPrecision, float * dense_pos, float * max_freq, float * mean_freq);
-unsigned int optimize_intervals_float_3D_opt(float *oriData, size_t r1, size_t r2, size_t r3, double realPrecision);
-unsigned int optimize_intervals_float_2D_opt(float *oriData, size_t r1, size_t r2, double realPrecision);
 unsigned int optimize_intervals_float_1D_opt(float *oriData, size_t dataLength, double realPrecision);
 
 unsigned int optimize_intervals_float_1D_opt_MSST19(float *oriData, size_t dataLength, double realPrecision);
-unsigned int optimize_intervals_float_2D_opt_MSST19(float *oriData, size_t r1, size_t r2, double realPrecision);
-unsigned int optimize_intervals_float_3D_opt_MSST19(float *oriData, size_t r1, size_t r2, size_t r3, double realPrecision);
 
 TightDataPointStorageF* SZ_compress_float_1D_MDQ(float *oriData, 
 size_t dataLength, float realPrecision, float valueRangeSize, float medianValue_f);
@@ -43,54 +34,17 @@ void SZ_compress_args_float_StoreOriData(float* oriData, size_t dataLength, unsi
 char SZ_compress_args_float_NoCkRngeNoGzip_1D(int cmprType, unsigned char** newByteData, float *oriData, 
 size_t dataLength, double realPrecision, size_t *outSize, float valueRangeSize, float medianValue_f);
 
-TightDataPointStorageF* SZ_compress_float_2D_MDQ(float *oriData, size_t r1, size_t r2, float realPrecision, float valueRangeSize, float medianValue_f);
-
-char SZ_compress_args_float_NoCkRngeNoGzip_2D(int cmprType, unsigned char** newByteData, float *oriData, size_t r1, size_t r2, double realPrecision, size_t *outSize, float valueRangeSize, float medianValue_f);
-
-TightDataPointStorageF* SZ_compress_float_3D_MDQ(float *oriData, size_t r1, size_t r2, size_t r3, float realPrecision, float valueRangeSize, float medianValue_f);
-
-char SZ_compress_args_float_NoCkRngeNoGzip_3D(int cmprType, unsigned char** newByteData, float *oriData, size_t r1, size_t r2, size_t r3, double realPrecision, size_t *outSize, float valueRangeSize, float medianValue_f);
-
 size_t SZ_compress_float_1D_MDQ_RA_block(float * block_ori_data, float * mean, size_t dim_0, size_t block_dim_0, double realPrecision, int * type, float * unpredictable_data);
-size_t SZ_compress_float_2D_MDQ_RA_block(float * block_ori_data, float * mean, size_t dim_0, size_t dim_1, size_t block_dim_0, size_t block_dim_1, double realPrecision, float * P0, float * P1, int * type, float * unpredictable_data);
 
 size_t SZ_compress_float_1D_MDQ_RA_block_1D_pred(float * block_ori_data, float * mean, float dense_pos, size_t dim_0, size_t block_dim_0, double realPrecision, int * type, DynamicFloatArray * unpredictable_data);
-size_t SZ_compress_float_2D_MDQ_RA_block_2D_pred(float * block_ori_data, float * mean, float dense_pos, size_t dim_0, size_t dim_1, size_t block_dim_0, size_t block_dim_1, double realPrecision, float * P0, float * P1, int * type, float * unpredictable_data);
-size_t SZ_compress_float_3D_MDQ_RA_block(float * block_ori_data, float * mean, size_t dim_0, size_t dim_1, size_t dim_2, size_t block_dim_0, size_t block_dim_1, size_t block_dim_2, float realPrecision, float * P0, float * P1, int * type, float * unpredictable_data);
-size_t SZ_compress_float_3D_MDQ_RA_block_3D_pred(float * block_ori_data, float * mean, float dense_pos, size_t dim_0, size_t dim_1, size_t dim_2, size_t block_dim_0, size_t block_dim_1, size_t block_dim_2, double realPrecision, float * P0, float * P1, int * type, float * unpredictable_data);
-size_t SZ_compress_float_3D_MDQ_RA_block_adaptive(float * block_ori_data, float * mean, size_t dim_0, size_t dim_1, size_t dim_2, size_t block_dim_0, size_t block_dim_1, size_t block_dim_2, double realPrecision, float * P0, float * P1, int * type, float * unpredictable_data);
-//unsigned short SZ_compress_float_3D_MDQ_RA_block_1D_pred(float * block_ori_data, float * mean, float dense_pos, size_t dim_0, size_t dim_1, size_t dim_2, int block_dim_0, int block_dim_1, int block_dim_2, double realPrecision, int * type, float * unpredictable_data);
-size_t SZ_compress_float_3D_MDQ_RA_block_3D_pred_flush_after_compare(float * block_ori_data, float * mean, float dense_pos, size_t dim_0, size_t dim_1, size_t dim_2, size_t block_dim_0, size_t block_dim_1, size_t block_dim_2, double realPrecision, float * P0, float * P1, int * type, float * unpredictable_data);
-size_t SZ_compress_float_3D_MDQ_RA_block_2_layers(float * block_ori_data, float * mean, size_t dim_0, size_t dim_1, size_t dim_2, size_t block_dim_0, size_t block_dim_1, size_t block_dim_2, double realPrecision, float * P0, float * P1, float * P_, int * type, float * unpredictable_data);
-size_t SZ_compress_float_3D_MDQ_pred_by_regression(float * block_ori_data, size_t dim_0, size_t dim_1, size_t dim_2, size_t block_dim_0, size_t block_dim_1, size_t block_dim_2, double realPrecision, float * reg_params, int * type, float * unpredictable_data);
 void SZ_blocked_regression(float * block_ori_data, size_t dim_0, size_t dim_1, size_t dim_2, size_t block_dim_0, size_t block_dim_1, size_t block_dim_2, float *params);
-unsigned char * SZ_compress_float_3D_MDQ_RA_all_by_regression(float *oriData, size_t r1, size_t r2, size_t r3, double realPrecision, size_t * comp_size);
-float SZ_compress_float_3D_MDQ_RA_block_no_mean(float * block_ori_data, size_t dim_0, size_t dim_1, size_t dim_2, size_t block_dim_0, size_t block_dim_1, size_t block_dim_2, double realPrecision, float * P0, float * P1, int * type, unsigned short * unpred_count, float * unpredictable_data);
-float SZ_compress_float_3D_MDQ_pred_by_regression_with_err(float * block_ori_data, size_t dim_0, size_t dim_1, size_t dim_2, size_t block_dim_0, size_t block_dim_1, size_t block_dim_2, double realPrecision, float * reg_params, int * type, unsigned short * unpred_count, float * unpredictable_data);
-unsigned char * SZ_compress_float_3D_MDQ_RA_blocked_with_regression(float *oriData, size_t r1, size_t r2, size_t r3, double realPrecision, size_t * comp_size);
-void decompressDataSeries_float_3D_RA_blocked_with_regression(float** data, size_t r1, size_t r2, size_t r3, unsigned char* comp_data);
 
 unsigned char * SZ_compress_float_1D_MDQ_RA(float *oriData, size_t r1, double realPrecision, size_t * comp_size);
-unsigned char * SZ_compress_float_2D_MDQ_RA(float *oriData, size_t r1, size_t r2, double realPrecision, size_t * comp_size);
-unsigned char * SZ_compress_float_2D_MDQ_nonblocked(float *oriData, size_t r1, size_t r2, double realPrecision, size_t * comp_size);
-unsigned char * SZ_compress_float_3D_MDQ_RA(float *oriData, size_t r1, size_t r2, size_t r3, double realPrecision, size_t * comp_size);
-unsigned char * SZ_compress_float_3D_MDQ_nonblocked(float *oriData, size_t r1, size_t r2, size_t r3, double realPrecision, size_t * comp_size);
-unsigned char * SZ_compress_float_3D_MDQ_nonblocked_ori(float *oriData, size_t r1, size_t r2, size_t r3, double realPrecision, size_t * comp_size);
-unsigned char * SZ_compress_float_3D_MDQ_nonblocked_multi_means(float *oriData, size_t r1, size_t r2, size_t r3, double realPrecision, size_t * comp_size);
-unsigned char * SZ_compress_float_3D_MDQ_RA_multi_means(float *oriData, size_t r1, size_t r2, size_t r3, double realPrecision, size_t * comp_size);
-unsigned char * SZ_compress_float_3D_MDQ_nonblocked_adaptive(float *oriData, size_t r1, size_t r2, size_t r3, double realPrecision, size_t * comp_size);
-
-unsigned char * SZ_compress_float_2D_MDQ_decompression_random_access_with_blocked_regression(float *oriData, size_t r1, size_t r2, double realPrecision, size_t * comp_size);
 unsigned char * SZ_compress_float_1D_MDQ_decompression_random_access_with_blocked_regression(float *oriData, size_t r1, double realPrecision, size_t * comp_size);
 
-TightDataPointStorageF* SZ_compress_float_4D_MDQ(float *oriData, size_t r1, size_t r2, size_t r3, size_t r4, double realPrecision, float valueRangeSize, float medianValue_f);
-
-char SZ_compress_args_float_NoCkRngeNoGzip_4D(unsigned char** newByteData, float *oriData, size_t r1, size_t r2, size_t r3, size_t r4, double realPrecision, size_t *outSize, float valueRangeSize, float medianValue_f);
 
 TightDataPointStorageF* SZ_compress_float_1D_MDQ_MSST19(float *oriData, 
 size_t dataLength, double realPrecision, float valueRangeSize, float medianValue_f);
-TightDataPointStorageF* SZ_compress_float_2D_MDQ_MSST19(float *oriData, size_t r1, size_t r2, double realPrecision, float valueRangeSize, float medianValue_f);
-TightDataPointStorageF* SZ_compress_float_3D_MDQ_MSST19(float *oriData, size_t r1, size_t r2, size_t r3, double realPrecision, float valueRangeSize, float medianValue_f);
 
 void SZ_compress_args_float_withinRange(unsigned char** newByteData, float *oriData, size_t dataLength, size_t *outSize);
 
@@ -111,40 +65,12 @@ size_t *outSize, int errBoundMode, double absErr_Bound, double relBoundRatio);
 void SZ_compress_args_float_NoCkRnge_1D_subblock(unsigned char* compressedBytes, float *oriData, double realPrecision, size_t *outSize, float valueRangeSize, float medianValue_f,
 size_t r1, size_t s1, size_t e1); 
 
-void SZ_compress_args_float_NoCkRnge_2D_subblock(unsigned char* compressedBytes, float *oriData, double realPrecision, size_t *outSize, float valueRangeSize, float medianValue_f,
-size_t r2, size_t r1, size_t s2, size_t s1, size_t e2, size_t e1); 
-
-void SZ_compress_args_float_NoCkRnge_3D_subblock(unsigned char* compressedBytes, float *oriData, double realPrecision, size_t *outSize, float valueRangeSize, float medianValue_f,
-size_t r3, size_t r2, size_t r1, size_t s3, size_t s2, size_t s1, size_t e3, size_t e2, size_t e1); 
-
-void SZ_compress_args_float_NoCkRnge_4D_subblock(unsigned char* compressedBytes, float *oriData, double realPrecision, size_t *outSize, float valueRangeSize, float medianValue_f,
-size_t r4, size_t r3, size_t r2, size_t r1, size_t s4, size_t s3, size_t s2, size_t s1, size_t e4, size_t e3, size_t e2, size_t e1);
 
 unsigned int optimize_intervals_float_1D_subblock(float *oriData, double realPrecision, size_t r1, size_t s1, size_t e1); 
-unsigned int optimize_intervals_float_2D_subblock(float *oriData, double realPrecision, size_t r1, size_t r2, size_t s1, size_t s2, size_t e1, size_t e2); 
-unsigned int optimize_intervals_float_3D_subblock(float *oriData, double realPrecision, size_t r1, size_t r2, size_t r3, size_t s1, size_t s2, size_t s3, size_t e1, size_t e2, size_t e3); 
-unsigned int optimize_intervals_float_4D_subblock(float *oriData, double realPrecision, size_t r1, size_t r2, size_t r3, size_t r4, size_t s1, size_t s2, size_t s3, size_t s4, size_t e1, size_t e2, size_t e3, size_t e4);
 
 TightDataPointStorageF* SZ_compress_float_1D_MDQ_subblock(float *oriData, double realPrecision, float valueRangeSize, float medianValue_f,
 size_t r1, size_t s1, size_t e1); 
 
-TightDataPointStorageF* SZ_compress_float_2D_MDQ_subblock(float *oriData, double realPrecision, float valueRangeSize, float medianValue_f,
-size_t r1, size_t r2, size_t s1, size_t s2, size_t e1, size_t e2); 
-
-TightDataPointStorageF* SZ_compress_float_3D_MDQ_subblock(float *oriData, double realPrecision, float valueRangeSize, float medianValue_f,
-size_t r1, size_t r2, size_t r3, size_t s1, size_t s2, size_t s3, size_t e1, size_t e2, size_t e3); 
-
-TightDataPointStorageF* SZ_compress_float_4D_MDQ_subblock(float *oriData, double realPrecision, float valueRangeSize, float medianValue_f,
-size_t r1, size_t r2, size_t r3, size_t r4, size_t s1, size_t s2, size_t s3, size_t s4, size_t e1, size_t e2, size_t e3, size_t e4);
-
-
-unsigned int optimize_intervals_float_2D_with_freq_and_dense_pos(float *oriData, size_t r1, size_t r2, double realPrecision, float * dense_pos, float * max_freq, float * mean_freq);
-unsigned int optimize_intervals_float_3D_with_freq_and_dense_pos(float *oriData, size_t r1, size_t r2, size_t r3, double realPrecision, float * dense_pos, float * max_freq, float * mean_freq);
-
-unsigned char * SZ_compress_float_2D_MDQ_nonblocked_with_blocked_regression(float *oriData, size_t r1, size_t r2, float realPrecision, size_t * comp_size);
-unsigned char * SZ_compress_float_3D_MDQ_nonblocked_with_blocked_regression(float *oriData, size_t r1, size_t r2, size_t r3, float realPrecision, size_t * comp_size);
-unsigned char * SZ_compress_float_3D_MDQ_random_access_with_blocked_regression(float *oriData, size_t r1, size_t r2, size_t r3, double realPrecision, size_t * comp_size);
-unsigned char * SZ_compress_float_3D_MDQ_decompression_random_access_with_blocked_regression(float *oriData, size_t r1, size_t r2, size_t r3, double realPrecision, size_t * comp_size);
 #ifdef __cplusplus
 }
 #endif

deps/SZ/sz/include/sz_float_pwr.h

@@ -19,24 +19,8 @@ extern "C" {
 
 void compute_segment_precisions_float_1D(float *oriData, size_t dataLength, float* pwrErrBound, unsigned char* pwrErrBoundBytes, double globalPrecision);
 unsigned int optimize_intervals_float_1D_pwr(float *oriData, size_t dataLength, float* pwrErrBound);
-
-void compute_segment_precisions_float_2D(float *oriData, float* pwrErrBound, 
-size_t r1, size_t r2, size_t R2, size_t edgeSize, unsigned char* pwrErrBoundBytes, float Min, float Max, double globalPrecision);
-
-unsigned int optimize_intervals_float_2D_pwr(float *oriData, size_t r1, size_t r2, size_t R2, size_t edgeSize, float* pwrErrBound); 
-
-void compute_segment_precisions_float_3D(float *oriData, float* pwrErrBound, 
-size_t r1, size_t r2, size_t r3, size_t R2, size_t R3, size_t edgeSize, unsigned char* pwrErrBoundBytes, float Min, float Max, double globalPrecision);
-
-unsigned int optimize_intervals_float_3D_pwr(float *oriData, size_t r1, size_t r2, size_t r3, size_t R2, size_t R3, size_t edgeSize, float* pwrErrBound);
-
 void SZ_compress_args_float_NoCkRngeNoGzip_1D_pwr(unsigned char** newByteData, float *oriData, double globalPrecision, size_t dataLength, size_t *outSize, float min, float max);
 
-void SZ_compress_args_float_NoCkRngeNoGzip_2D_pwr(unsigned char** newByteData, float *oriData, double globalPrecision, size_t r1, size_t r2, 
-size_t *outSize, float min, float max);
-
-void SZ_compress_args_float_NoCkRngeNoGzip_3D_pwr(unsigned char** newByteData, float *oriData, double globalPrecision, size_t r1, size_t r2, 
-size_t r3, size_t *outSize, float min, float max);
 
 void createRangeGroups_float(float** posGroups, float** negGroups, int** posFlags, int** negFlags);
 void compressGroupIDArray_float(char* groupID, TightDataPointStorageF* tdps);
@@ -48,15 +32,8 @@ void SZ_compress_args_float_NoCkRngeNoGzip_1D_pwrgroup(unsigned char** newByteDa
 size_t dataLength, double absErrBound, double relBoundRatio, double pwrErrRatio, float valueRangeSize, float medianValue_f, size_t *outSize);
 
 void SZ_compress_args_float_NoCkRngeNoGzip_1D_pwr_pre_log(unsigned char** newByteData, float *oriData, double pwrErrRatio, size_t dataLength, size_t *outSize, float min, float max);
-void SZ_compress_args_float_NoCkRngeNoGzip_2D_pwr_pre_log(unsigned char** newByteData, float *oriData, double pwrErrRatio, size_t r1, size_t r2, size_t *outSize, float min, float max);
-void SZ_compress_args_float_NoCkRngeNoGzip_3D_pwr_pre_log(unsigned char** newByteData, float *oriData, double pwrErrRatio, size_t r1, size_t r2, size_t r3, size_t *outSize, float min, float max);
-
 void SZ_compress_args_float_NoCkRngeNoGzip_1D_pwr_pre_log_MSST19(unsigned char** newByteData, float *oriData, double pwrErrRatio, size_t dataLength, size_t *outSize, float valueRangeSize, float medianValue_f,
 																unsigned char* signs, bool* positive, float min, float max, float nearZero);
-void SZ_compress_args_float_NoCkRngeNoGzip_2D_pwr_pre_log_MSST19(unsigned char** newByteData, float *oriData, double pwrErrRatio, size_t r1, size_t r2, size_t *outSize, float valueRangeSize,
-																unsigned char* signs, bool* positive, float min, float max, float nearZero);																
-void SZ_compress_args_float_NoCkRngeNoGzip_3D_pwr_pre_log_MSST19(unsigned char** newByteData, float *oriData, double pwrErrRatio, size_t r1, size_t r2, size_t r3, size_t *outSize, float valueRangeSize, 
-																unsigned char* signs, bool* positive, float min, float max, float nearZero);
 
 #ifdef __cplusplus
 }

deps/SZ/sz/include/szd_double.h

@@ -17,22 +17,10 @@ extern "C" {
 #include "TightDataPointStorageD.h"
 
 void decompressDataSeries_double_1D(double** data, size_t dataSeriesLength, double* hist_data, TightDataPointStorageD* tdps);
-void decompressDataSeries_double_2D(double** data, size_t r1, size_t r2, double* hist_data, TightDataPointStorageD* tdps);
-void decompressDataSeries_double_3D(double** data, size_t r1, size_t r2, size_t r3, double* hist_data, TightDataPointStorageD* tdps);
-void decompressDataSeries_double_4D(double** data, size_t r1, size_t r2, size_t r3, size_t r4, double* hist_data, TightDataPointStorageD* tdps);
 
 void decompressDataSeries_double_1D_MSST19(double** data, size_t dataSeriesLength, TightDataPointStorageD* tdps);
-void decompressDataSeries_double_2D_MSST19(double** data, size_t r1, size_t r2, TightDataPointStorageD* tdps);
-void decompressDataSeries_double_3D_MSST19(double** data, size_t r1, size_t r2, size_t r3, TightDataPointStorageD* tdps);
 
 void getSnapshotData_double_1D(double** data, size_t dataSeriesLength, TightDataPointStorageD* tdps, int errBoundMode, int compressionType, double* hist_data, sz_params* pde_params);
-void getSnapshotData_double_2D(double** data, size_t r1, size_t r2, TightDataPointStorageD* tdps, int errBoundMode, int compressionType, double* hist_data);
-void getSnapshotData_double_3D(double** data, size_t r1, size_t r2, size_t r3, TightDataPointStorageD* tdps, int errBoundMode, int compressionType, double* hist_data);
-void getSnapshotData_double_4D(double** data, size_t r1, size_t r2, size_t r3, size_t r4, TightDataPointStorageD* tdps, int errBoundMode, int compressionType, double* hist_data);
-void decompressDataSeries_double_2D_nonblocked_with_blocked_regression(double** data, size_t r1, size_t r2, unsigned char* comp_data, double* hist_data);
-void decompressDataSeries_double_3D_nonblocked_with_blocked_regression(double** data, size_t r1, size_t r2, size_t r3, unsigned char* comp_data, double* hist_data);
-
-size_t decompressDataSeries_double_3D_RA_block(double * data, double mean, size_t dim_0, size_t dim_1, size_t dim_2, size_t block_dim_0, size_t block_dim_1, size_t block_dim_2, double realPrecision, int * type, double * unpredictable_data);
 
 int SZ_decompress_args_double(double** newData, size_t r5, size_t r4, size_t r3, size_t r2, size_t r1, unsigned char* cmpBytes, size_t cmpSize, int compressionType, double* hist_data, sz_exedata* pde_exe, sz_params* pde_params);
 

deps/SZ/sz/include/szd_double_pwr.h

@@ -15,19 +15,11 @@ extern "C" {
 #endif
 
 void decompressDataSeries_double_1D_pwr(double** data, size_t dataSeriesLength, TightDataPointStorageD* tdps);
-double* extractRealPrecision_2D_double(size_t R1, size_t R2, int blockSize, TightDataPointStorageD* tdps);
-void decompressDataSeries_double_2D_pwr(double** data, size_t r1, size_t r2, TightDataPointStorageD* tdps);
-double* extractRealPrecision_3D_double(size_t R1, size_t R2, size_t R3, int blockSize, TightDataPointStorageD* tdps);
-void decompressDataSeries_double_3D_pwr(double** data, size_t r1, size_t r2, size_t r3, TightDataPointStorageD* tdps);
 
 void decompressDataSeries_double_1D_pwrgroup(double** data, size_t dataSeriesLength, TightDataPointStorageD* tdps);
 void decompressDataSeries_double_1D_pwr_pre_log(double** data, size_t dataSeriesLength, TightDataPointStorageD* tdps);
-void decompressDataSeries_double_2D_pwr_pre_log(double** data, size_t r1, size_t r2, TightDataPointStorageD* tdps);
-void decompressDataSeries_double_3D_pwr_pre_log(double** data, size_t r1, size_t r2, size_t r3, TightDataPointStorageD* tdps);
 
 void decompressDataSeries_double_1D_pwr_pre_log_MSST19(double** data, size_t dataSeriesLength, TightDataPointStorageD* tdps);
-void decompressDataSeries_double_2D_pwr_pre_log_MSST19(double** data, size_t r1, size_t r2, TightDataPointStorageD* tdps);
-void decompressDataSeries_double_3D_pwr_pre_log_MSST19(double** data, size_t r1, size_t r2, size_t r3, TightDataPointStorageD* tdps);
 
 #ifdef __cplusplus
 }

deps/SZ/sz/include/szd_float.h

@@ -17,34 +17,18 @@ extern "C" {
 #include "TightDataPointStorageF.h"
 
 void decompressDataSeries_float_1D(float** data, size_t dataSeriesLength, float* hist_data, TightDataPointStorageF* tdps);
-void decompressDataSeries_float_2D(float** data, size_t r1, size_t r2, float* hist_data, TightDataPointStorageF* tdps);
-void decompressDataSeries_float_3D(float** data, size_t r1, size_t r2, size_t r3, float* hist_data, TightDataPointStorageF* tdps);
-void decompressDataSeries_float_4D(float** data, size_t r1, size_t r2, size_t r3, size_t r4, float* hist_data, TightDataPointStorageF* tdps);
 
 void decompressDataSeries_float_1D_MSST19(float** data, size_t dataSeriesLength, TightDataPointStorageF* tdps);
-void decompressDataSeries_float_2D_MSST19(float** data, size_t r1, size_t r2, TightDataPointStorageF* tdps);
-void decompressDataSeries_float_3D_MSST19(float** data, size_t r1, size_t r2, size_t r3, TightDataPointStorageF* tdps);
 
 void getSnapshotData_float_1D(float** data, size_t dataSeriesLength, TightDataPointStorageF* tdps, int errBoundMode, int compressionType, float* hist_data, sz_params* pde_params);
-void getSnapshotData_float_2D(float** data, size_t r1, size_t r2, TightDataPointStorageF* tdps, int errBoundMode, int compressionType, float* hist_data);
-void getSnapshotData_float_3D(float** data, size_t r1, size_t r2, size_t r3, TightDataPointStorageF* tdps, int errBoundMode, int compressionType, float* hist_data);
-void getSnapshotData_float_4D(float** data, size_t r1, size_t r2, size_t r3, size_t r4, TightDataPointStorageF* tdps, int errBoundMode, int compressionType, float* hist_data);
 
 size_t decompressDataSeries_float_1D_RA_block(float * data, float mean, size_t dim_0, size_t block_dim_0, double realPrecision, int * type, float * unpredictable_data);
-size_t decompressDataSeries_float_2D_RA_block(float * data, float mean, size_t dim_0, size_t dim_1, size_t block_dim_0, size_t block_dim_1, double realPrecision, int * type, float * unpredictable_data);
 
 int SZ_decompress_args_float(float** newData, size_t r5, size_t r4, size_t r3, size_t r2, size_t r1, unsigned char* cmpBytes, size_t cmpSize, int compressionType, float* hist_data, sz_exedata* pde_exe, sz_params* pde_params);
 
-size_t decompressDataSeries_float_3D_RA_block(float * data, float mean, size_t dim_0, size_t dim_1, size_t dim_2, size_t block_dim_0, size_t block_dim_1, size_t block_dim_2, double realPrecision, int * type, float * unpredictable_data);
 
 void decompressDataSeries_float_1D_decompression_given_areas_with_blocked_regression(float** data, size_t r1, size_t s1, size_t e1, unsigned char* comp_data);
 
-void decompressDataSeries_float_2D_nonblocked_with_blocked_regression(float** data, size_t r1, size_t r2, unsigned char* comp_data, float* hist_data);
-void decompressDataSeries_float_2D_decompression_given_areas_with_blocked_regression(float** data, size_t r1, size_t r2, size_t s1, size_t s2, size_t e1, size_t e2, unsigned char* comp_data);
-void decompressDataSeries_float_3D_nonblocked_with_blocked_regression(float** data, size_t r1, size_t r2, size_t r3, unsigned char* comp_data, float* hist_data);
-void decompressDataSeries_float_3D_random_access_with_blocked_regression(float** data, size_t r1, size_t r2, size_t r3, unsigned char* comp_data);
-void decompressDataSeries_float_3D_decompression_random_access_with_blocked_regression(float** data, size_t r1, size_t r2, size_t r3, unsigned char* comp_data);
-void decompressDataSeries_float_3D_decompression_given_areas_with_blocked_regression(float** data, size_t r1, size_t r2, size_t r3, size_t s1, size_t s2, size_t s3, size_t e1, size_t e2, size_t e3, unsigned char* comp_data);
 int SZ_decompress_args_randomaccess_float(float** newData, 
 size_t r5, size_t r4, size_t r3, size_t r2, size_t r1, 
 size_t s5, size_t s4, size_t s3, size_t s2, size_t s1, // start point

deps/SZ/sz/include/szd_float_pwr.h

@@ -15,20 +15,12 @@ extern "C" {
 #endif
 
 void decompressDataSeries_float_1D_pwr(float** data, size_t dataSeriesLength, TightDataPointStorageF* tdps);
-float* extractRealPrecision_2D_float(size_t R1, size_t R2, int blockSize, TightDataPointStorageF* tdps);
-void decompressDataSeries_float_2D_pwr(float** data, size_t r1, size_t r2, TightDataPointStorageF* tdps);
-float* extractRealPrecision_3D_float(size_t R1, size_t R2, size_t R3, int blockSize, TightDataPointStorageF* tdps);
-void decompressDataSeries_float_3D_pwr(float** data, size_t r1, size_t r2, size_t r3, TightDataPointStorageF* tdps);
 
 char* decompressGroupIDArray(unsigned char* bytes, size_t dataLength);
 void decompressDataSeries_float_1D_pwrgroup(float** data, size_t dataSeriesLength, TightDataPointStorageF* tdps);
 void decompressDataSeries_float_1D_pwr_pre_log(float** data, size_t dataSeriesLength, TightDataPointStorageF* tdps);
-void decompressDataSeries_float_2D_pwr_pre_log(float** data, size_t r1, size_t r2, TightDataPointStorageF* tdps);
-void decompressDataSeries_float_3D_pwr_pre_log(float** data, size_t r1, size_t r2, size_t r3, TightDataPointStorageF* tdps);
 
 void decompressDataSeries_float_1D_pwr_pre_log_MSST19(float** data, size_t dataSeriesLength, TightDataPointStorageF* tdps);
-void decompressDataSeries_float_2D_pwr_pre_log_MSST19(float** data, size_t r1, size_t r2, TightDataPointStorageF* tdps);
-void decompressDataSeries_float_3D_pwr_pre_log_MSST19(float** data, size_t r1, size_t r2, size_t r3, TightDataPointStorageF* tdps);
 
 #ifdef __cplusplus
 }

deps/SZ/sz/src/TightDataPointStorageD.c

@@ -71,14 +71,11 @@ int new_TightDataPointStorageD_fromFlatBytes(TightDataPointStorageD **this, unsi
 	}
 
 	int same = sameRByte & 0x01;
-	//confparams_dec->szMode = (sameRByte & 0x06)>>1;
 	(*this)->isLossless = (sameRByte & 0x10)>>4;
 	int isPW_REL = (sameRByte & 0x20)>>5;
 	exe_params->SZ_SIZE_TYPE = ((sameRByte & 0x40)>>6)==1?8:4;
-	//confparams_dec->randomAccess = (sameRByte & 0x02) >> 1;
-	//confparams_dec->szMode = (sameRByte & 0x06) >> 1;						//this 0000,0110	are not used for szMode any more
-	confparams_dec->protectValueRange = (sameRByte & 0x04)>>2;
-	confparams_dec->accelerate_pw_rel_compression = (sameRByte & 0x08) >> 3;
+	pde_params->protectValueRange = (sameRByte & 0x04)>>2;
+	pde_params->accelerate_pw_rel_compression = (sameRByte & 0x08) >> 3;
 	int errorBoundMode = ABS;
 	if(isPW_REL)
 	{
@@ -87,12 +84,7 @@ int new_TightDataPointStorageD_fromFlatBytes(TightDataPointStorageD **this, unsi
 		pwrErrBoundBytesL = 4;
 	}
 	
-	if(confparams_dec==NULL)
-	{
-		confparams_dec = (sz_params*)malloc(sizeof(sz_params));
-		memset(confparams_dec, 0, sizeof(sz_params));
-	}	
-	convertBytesToSZParams(&(flatBytes[index]), confparams_dec, pde_exe);
+	convertBytesToSZParams(&(flatBytes[index]), pde_params, pde_exe);
 
 	index += MetaDataByteLength_double;
 
@@ -103,8 +95,6 @@ int new_TightDataPointStorageD_fromFlatBytes(TightDataPointStorageD **this, unsi
 		dsLengthBytes[i] = flatBytes[index++];
 	(*this)->dataSeriesLength = bytesToSize(dsLengthBytes);
 
-	//printf("confparams_dec->szMode=%d\n",confparams_dec->szMode);
-
 	if((*this)->isLossless==1)
 	{
 		//(*this)->exactMidBytes = flatBytes+8;
@@ -135,7 +125,7 @@ int new_TightDataPointStorageD_fromFlatBytes(TightDataPointStorageD **this, unsi
 		byteBuf[i] = flatBytes[index++];
 	int max_quant_intervals = bytesToInt_bigEndian(byteBuf);// 4	
 
-	confparams_dec->maxRangeRadius = max_quant_intervals/2;
+	pde_params->maxRangeRadius = max_quant_intervals/2;
 
 	if(errorBoundMode>=PW_REL)
 	{
@@ -143,7 +133,7 @@ int new_TightDataPointStorageD_fromFlatBytes(TightDataPointStorageD **this, unsi
 		radExpoL = 1;
 		for (i = 0; i < exe_params->SZ_SIZE_TYPE; i++)
 			byteBuf[i] = flatBytes[index++];
-		confparams_dec->segment_size = (*this)->segment_size = bytesToSize(byteBuf);// exe_params->SZ_SIZE_TYPE	
+		pde_params->segment_size = (*this)->segment_size = bytesToSize(byteBuf);// exe_params->SZ_SIZE_TYPE	
 
 		for (i = 0; i < 4; i++)
 			byteBuf[i] = flatBytes[index++];
@@ -165,7 +155,7 @@ int new_TightDataPointStorageD_fromFlatBytes(TightDataPointStorageD **this, unsi
 
 	(*this)->reqLength = flatBytes[index++]; //1
 	
-	if(isPW_REL && confparams_dec->accelerate_pw_rel_compression)
+	if(isPW_REL && pde_params->accelerate_pw_rel_compression)
 	{
 		(*this)->plus_bits = flatBytes[index++];
 		(*this)->max_bits = flatBytes[index++];

deps/SZ/sz/src/TightDataPointStorageI.c

-/**
- *  @file TightPointDataStorageI.c
- *  @author Sheng Di and Dingwen Tao
- *  @date Aug, 2016
- *  @brief The functions used to construct the tightPointDataStorage element for storing compressed bytes.
- *  (C) 2016 by Mathematics and Computer Science (MCS), Argonne National Laboratory.
- *      See COPYRIGHT in top-level directory.
- */
-
-#include <stdlib.h> 
-#include <stdio.h>
-#include <string.h>
-#include <math.h>
-#include "TightDataPointStorageI.h"
-#include "sz.h"
-#include "Huffman.h"
-//#include "rw.h"
-
-int computeRightShiftBits(int exactByteSize, int dataType)
-{
-	int rightShift = 0; 
-	switch(dataType)
-	{
-	case SZ_INT8:
-	case SZ_UINT8:
-		rightShift = 8 - exactByteSize*8;
-		break;
-	case SZ_INT16:
-	case SZ_UINT16:
-		rightShift = 16 - exactByteSize*8;
-		break;
-	case SZ_INT32:
-	case SZ_UINT32:
-		rightShift = 32 - exactByteSize*8;
-		break;
-	case SZ_INT64:
-	case SZ_UINT64:
-		rightShift = 64 - exactByteSize*8;
-		break;
-	}
-	return rightShift;	
-}
-
-int convertDataTypeSizeCode(int dataTypeSizeCode)
-{
-	int result = 0;
-	switch(dataTypeSizeCode)
-	{
-	case 0:
-		result = 1;
-		break;
-	case 1:
-		result = 2;
-		break;
-	case 2:
-		result = 4;
-		break;
-	case 3:
-		result = 8;
-		break;
-	}
-	return result;	
-}
-
-int convertDataTypeSize(int dataTypeSize)
-{
-	int result = 0;
-	switch(dataTypeSize)
-	{
-	case 1:
-		result = 0; //0000
-		break;
-	case 2:
-		result = 4; //0100
-		break;
-	case 4:
-		result = 8; //1000
-		break;
-	case 8:
-		result = 12; //1100
-		break;
-	}
-	return result;
-}
-
-void new_TightDataPointStorageI_Empty(TightDataPointStorageI **this)
-{
-	*this = (TightDataPointStorageI*)malloc(sizeof(TightDataPointStorageI));
-
-	(*this)->dataSeriesLength = 0;
-	(*this)->allSameData = 0;
-	(*this)->exactDataNum = 0;
-	(*this)->realPrecision = 0;
-	(*this)->minValue = 0;
-	(*this)->exactByteSize = 0;
-
-	(*this)->typeArray = NULL; //its size is dataSeriesLength/4 (or xxx/4+1) 
-	(*this)->typeArray_size = 0;
-	
-	(*this)->exactDataBytes = NULL;
-	(*this)->exactDataBytes_size = 0;
-
-	(*this)->intervals = 0;
-	(*this)->isLossless = 0;	
-}
-
-int new_TightDataPointStorageI_fromFlatBytes(TightDataPointStorageI **this, unsigned char* flatBytes, size_t flatBytesLength)
-{
-	new_TightDataPointStorageI_Empty(this);
-	size_t i, index = 0;
-	char version[3];
-	for (i = 0; i < 3; i++)
-		version[i] = flatBytes[index++]; //3
-	unsigned char sameRByte = flatBytes[index++]; //1
-	if(checkVersion2(version)!=1)
-	{
-		//wrong version
-		printf("Wrong version: \nCompressed-data version (%d.%d.%d)\n",version[0], version[1], version[2]);
-		printf("Current sz version: (%d.%d.%d)\n", versionNumber[0], versionNumber[1], versionNumber[2]);
-		printf("Please double-check if the compressed data (or file) is correct.\n");
-		exit(0);
-	}
-	int same = sameRByte & 0x01;
-	//conf_params->szMode = (sameRByte & 0x06)>>1;
-	int dataByteSizeCode = (sameRByte & 0x0C)>>2;
-	convertDataTypeSizeCode(dataByteSizeCode); //in bytes
-	(*this)->isLossless = (sameRByte & 0x10)>>4;
-
-	exe_params->SZ_SIZE_TYPE = ((sameRByte & 0x40)>>6)==1?8:4;
-	int errorBoundMode = ABS;
-	
-	if(confparams_dec==NULL)
-	{
-		confparams_dec = (sz_params*)malloc(sizeof(sz_params));
-		memset(confparams_dec, 0, sizeof(sz_params));
-	}	
-	convertBytesToSZParams(&(flatBytes[index]), confparams_dec, exe_params);
-	/*sz_params* params = convertBytesToSZParams(&(flatBytes[index]));
-	int mode = confparams_dec->szMode;
-	int losslessCompressor = confparams_dec->losslessCompressor;
-	if(confparams_dec!=NULL)
-		free(confparams_dec);
-	confparams_dec = params;
-	confparams_dec->szMode = mode;
-	confparams_dec->losslessCompressor = losslessCompressor;*/
-	
-	index += MetaDataByteLength; //20	
-	
-	if(same==0)
-		(*this)->exactByteSize = flatBytes[index++]; //1
-	
-	unsigned char dsLengthBytes[8];
-	for (i = 0; i < exe_params->SZ_SIZE_TYPE; i++)
-		dsLengthBytes[i] = flatBytes[index++];
-	(*this)->dataSeriesLength = bytesToSize(dsLengthBytes);// ST
-	if((*this)->isLossless==1)
-	{
-		//(*this)->exactMidBytes = flatBytes+8;
-		return errorBoundMode;
-	}
-	else if(same==1)
-	{
-		(*this)->allSameData = 1;
-		(*this)->exactDataBytes = &(flatBytes[index]);
-		return errorBoundMode;
-	}
-	else
-		(*this)->allSameData = 0;
-
-	unsigned char byteBuf[8];
-
-	for (i = 0; i < 4; i++)
-		byteBuf[i] = flatBytes[index++];
-	int max_quant_intervals = bytesToInt_bigEndian(byteBuf);// 4	
-
-	confparams_dec->maxRangeRadius = max_quant_intervals/2;
-
-	if(errorBoundMode>=PW_REL)
-	{
-		printf("Error: errorBoundMode>=PW_REL in new_TightDataPointStorageI_fromFlatBytes!! Wrong...\n");
-		exit(0);
-	}
-
-	for (i = 0; i < 4; i++)
-		byteBuf[i] = flatBytes[index++];
-	(*this)->intervals = bytesToInt_bigEndian(byteBuf);// 4	
-
-	for (i = 0; i < 8; i++)
-		byteBuf[i] = flatBytes[index++];
-	(*this)->minValue = bytesToLong_bigEndian(byteBuf); //8
-		
-	for (i = 0; i < 8; i++)
-		byteBuf[i] = flatBytes[index++];
-	(*this)->realPrecision = bytesToDouble(byteBuf);//8
-	
-	for (i = 0; i < exe_params->SZ_SIZE_TYPE; i++)
-		byteBuf[i] = flatBytes[index++];
-	(*this)->typeArray_size = bytesToSize(byteBuf);// ST		
-
-	for (i = 0; i < exe_params->SZ_SIZE_TYPE; i++)
-		byteBuf[i] = flatBytes[index++];
-	(*this)->exactDataNum = bytesToSize(byteBuf);// ST
-	
-	for (i = 0; i < exe_params->SZ_SIZE_TYPE; i++)
-		byteBuf[i] = flatBytes[index++];
-	(*this)->exactDataBytes_size = bytesToSize(byteBuf);// ST		
-
-
-	(*this)->typeArray = &flatBytes[index];
-	//retrieve the number of states (i.e., stateNum)
-	(*this)->allNodes = bytesToInt_bigEndian((*this)->typeArray); //the first 4 bytes store the stateNum
-	(*this)->stateNum = ((*this)->allNodes+1)/2;		
-
-	index+=(*this)->typeArray_size;
-	
-	if((*this)->exactDataBytes_size > 0)
-	{	
-		(*this)->exactDataBytes = &flatBytes[index];
-		index+=(*this)->exactDataBytes_size*sizeof(char);	
-	}
-	else
-		(*this)->exactDataBytes = NULL;	
-	return errorBoundMode;
-}
-
-/**
- *
- * type's length == dataSeriesLength
- * exactDataBytes's length == exactDataBytes_size
- * */
-void new_TightDataPointStorageI(TightDataPointStorageI **this,
-		size_t dataSeriesLength, size_t exactDataNum, int byteSize, 
-		int* type, unsigned char* exactDataBytes, size_t exactDataBytes_size,
-		double realPrecision, long minValue, int intervals, int dataType) 
-{
-	//int i = 0;
-	*this = (TightDataPointStorageI *)malloc(sizeof(TightDataPointStorageI));
-	(*this)->allSameData = 0;
-	(*this)->realPrecision = realPrecision;
-	(*this)->minValue = minValue;
-	switch(dataType)
-	{
-	case SZ_INT8:
-	case SZ_UINT8:
-		(*this)->dataTypeSize = 1;
-		break;
-	case SZ_INT16:
-	case SZ_UINT16:
-		(*this)->dataTypeSize = 2;
-		break;
-	case SZ_INT32:
-	case SZ_UINT32:
-		(*this)->dataTypeSize = 4;
-		break;
-	case SZ_INT64:
-	case SZ_UINT64:
-		(*this)->dataTypeSize = 8;
-		break;
-	}
-
-	(*this)->dataSeriesLength = dataSeriesLength;
-	(*this)->exactDataNum = exactDataNum;
-	(*this)->exactByteSize = byteSize;
-
-
-	int stateNum = 2*intervals;
-	HuffmanTree* huffmanTree = createHuffmanTree(stateNum);
-	encode_withTree(huffmanTree, type, dataSeriesLength, &(*this)->typeArray, &(*this)->typeArray_size);
-	SZ_ReleaseHuffman(huffmanTree);
-		
-	(*this)->exactDataBytes = exactDataBytes;
-	(*this)->exactDataBytes_size = exactDataBytes_size;
-	
-	(*this)->intervals = intervals;
-	
-	(*this)->isLossless = 0;
-}
-
-void convertTDPStoBytes_int(TightDataPointStorageI* tdps, unsigned char* bytes, unsigned char sameByte)
-{
-	size_t i, k = 0;
-	
-	unsigned char byteBuffer[8] = {0,0,0,0,0,0,0,0};
-	
-	for(i = 0;i<3;i++)//3 bytes
-		bytes[k++] = versionNumber[i];
-	bytes[k++] = sameByte;	//1	byte
-	
-	convertSZParamsToBytes(confparams_cpr, &(bytes[k]));
-	k = k + MetaDataByteLength;	
-		
-	bytes[k++] = tdps->exactByteSize; //1 byte
-
-	sizeToBytes(byteBuffer, tdps->dataSeriesLength);
-	for(i = 0;i<exe_params->SZ_SIZE_TYPE;i++)//ST: 4 or 8 bytes
-		bytes[k++] = byteBuffer[i];	
-	
-	intToBytes_bigEndian(byteBuffer, confparams_cpr->max_quant_intervals);
-	for(i = 0;i<4;i++)//4
-		bytes[k++] = byteBuffer[i];
-	
-	intToBytes_bigEndian(byteBuffer, tdps->intervals);
-	for(i = 0;i<4;i++)//4
-		bytes[k++] = byteBuffer[i];			
-	
-	longToBytes_bigEndian(byteBuffer, tdps->minValue);
-	for (i = 0; i < 8; i++)// 8
-		bytes[k++] = byteBuffer[i];
-
-	doubleToBytes(byteBuffer, tdps->realPrecision);
-	for (i = 0; i < 8; i++)// 8
-		bytes[k++] = byteBuffer[i];			
-
-	sizeToBytes(byteBuffer, tdps->typeArray_size);
-	for(i = 0;i<exe_params->SZ_SIZE_TYPE;i++)//ST
-		bytes[k++] = byteBuffer[i];
-
-	sizeToBytes(byteBuffer, tdps->exactDataNum);
-	for(i = 0;i<exe_params->SZ_SIZE_TYPE;i++)//ST
-		bytes[k++] = byteBuffer[i];
-
-	sizeToBytes(byteBuffer, tdps->exactDataBytes_size);
-	for(i = 0;i<exe_params->SZ_SIZE_TYPE;i++)//ST
-		bytes[k++] = byteBuffer[i];
-
-	memcpy(&(bytes[k]), tdps->typeArray, tdps->typeArray_size);
-	k += tdps->typeArray_size;
-
-	memcpy(&(bytes[k]), tdps->exactDataBytes, tdps->exactDataBytes_size);
-	k += tdps->exactDataBytes_size;
-}
-
-//convert TightDataPointStorageI to bytes...
-void convertTDPStoFlatBytes_int(TightDataPointStorageI *tdps, unsigned char** bytes, size_t *size)
-{
-	size_t i, k = 0; 
-	unsigned char dsLengthBytes[8];
-	
-	if(exe_params->SZ_SIZE_TYPE==4)
-		intToBytes_bigEndian(dsLengthBytes, tdps->dataSeriesLength);//4
-	else
-		longToBytes_bigEndian(dsLengthBytes, tdps->dataSeriesLength);//8
-
-	unsigned char sameByte = tdps->allSameData==1?(unsigned char)1:(unsigned char)0;
-	sameByte = sameByte | (confparams_cpr->szMode << 1);
-	if(tdps->isLossless)
-		sameByte = (unsigned char) (sameByte | 0x10);
-	
-	int dataTypeSizeCode = convertDataTypeSize(tdps->dataTypeSize);
-	sameByte = (unsigned char) (sameByte | dataTypeSizeCode);
-	
-	if(exe_params->SZ_SIZE_TYPE==8)
-		sameByte = (unsigned char) (sameByte | 0x40); // 01000000, the 6th bit
-	
-	if(tdps->allSameData==1)
-	{
-		size_t totalByteLength = 3 + 1 + MetaDataByteLength + exe_params->SZ_SIZE_TYPE + tdps->exactDataBytes_size;
-		*bytes = (unsigned char *)malloc(sizeof(unsigned char)*totalByteLength);
-
-		for (i = 0; i < 3; i++)//3
-			(*bytes)[k++] = versionNumber[i];
-		(*bytes)[k++] = sameByte;//1
-		
-		convertSZParamsToBytes(confparams_cpr, &((*bytes)[k]));
-		k = k + MetaDataByteLength;			
-		
-		for (i = 0; i < exe_params->SZ_SIZE_TYPE; i++)
-			(*bytes)[k++] = dsLengthBytes[i];
-		
-		for (i = 0; i < tdps->exactDataBytes_size; i++)
-			(*bytes)[k++] = tdps->exactDataBytes[i];
-
-		*size = totalByteLength;
-	}
-	else 
-	{
-		if(confparams_cpr->errorBoundMode>=PW_REL)
-		{			
-			printf("Error: errorBoundMode >= PW_REL!! can't be...\n");
-			exit(0);
-		}
-
-		size_t totalByteLength = 3 + 1 + MetaDataByteLength + 1 + exe_params->SZ_SIZE_TYPE + 4 + 4 + 8 + 8
-				+ exe_params->SZ_SIZE_TYPE + exe_params->SZ_SIZE_TYPE + exe_params->SZ_SIZE_TYPE
-				+ tdps->typeArray_size + tdps->exactDataBytes_size;
-
-		*bytes = (unsigned char *)malloc(sizeof(unsigned char)*totalByteLength);
-
-		convertTDPStoBytes_int(tdps, *bytes, sameByte);
-		
-		*size = totalByteLength;
-	}
-}
-
-void convertTDPStoFlatBytes_int_args(TightDataPointStorageI *tdps, unsigned char* bytes, size_t *size)
-{
-	size_t i, k = 0; 
-	unsigned char dsLengthBytes[8];
-	
-	if(exe_params->SZ_SIZE_TYPE==4)
-		intToBytes_bigEndian(dsLengthBytes, tdps->dataSeriesLength);//4
-	else
-		longToBytes_bigEndian(dsLengthBytes, tdps->dataSeriesLength);//8
-		
-	unsigned char sameByte = tdps->allSameData==1?(unsigned char)1:(unsigned char)0;
-	sameByte = sameByte | (confparams_cpr->szMode << 1);
-	if(tdps->isLossless)
-		sameByte = (unsigned char) (sameByte | 0x10);
-	if(exe_params->SZ_SIZE_TYPE==8)
-		sameByte = (unsigned char) (sameByte | 0x40); // 01000000, the 6th bit
-		
-	if(tdps->allSameData==1)
-	{
-		size_t totalByteLength = 3 + 1 + MetaDataByteLength + exe_params->SZ_SIZE_TYPE + tdps->exactDataBytes_size;
-		//*bytes = (unsigned char *)malloc(sizeof(unsigned char)*totalByteLength);
-
-		for (i = 0; i < 3; i++)//3
-			bytes[k++] = versionNumber[i];
-		bytes[k++] = sameByte;//1
-		
-		convertSZParamsToBytes(confparams_cpr, &(bytes[k]));
-		k = k + MetaDataByteLength;	
-				
-		for (i = 0; i < exe_params->SZ_SIZE_TYPE; i++)//ST
-			bytes[k++] = dsLengthBytes[i];		
-		for (i = 0; i < tdps->exactDataBytes_size; i++)
-			bytes[k++] = tdps->exactDataBytes[i];
-
-		*size = totalByteLength;
-	}
-	else
-	{
-		if(confparams_cpr->errorBoundMode>=PW_REL)
-		{			
-			printf("Error: errorBoundMode>=PW_REL!! can't be....\n");
-			exit(0);
-		}
-
-		size_t totalByteLength = 3 + 1 + MetaDataByteLength + exe_params->SZ_SIZE_TYPE + 1 + 4 + 4 + 8 + 8
-				+ exe_params->SZ_SIZE_TYPE + exe_params->SZ_SIZE_TYPE + exe_params->SZ_SIZE_TYPE  
-				+ tdps->typeArray_size + tdps->exactDataBytes_size;
-
-		convertTDPStoBytes_int(tdps, bytes, sameByte);
-		
-		*size = totalByteLength;
-	}
-}
-
-void free_TightDataPointStorageI(TightDataPointStorageI *tdps)
-{
-	if(tdps->typeArray!=NULL)
-		free(tdps->typeArray);
-	if(tdps->exactDataBytes!=NULL)
-		free(tdps->exactDataBytes);
-	free(tdps);
-}
-
-void free_TightDataPointStorageI2(TightDataPointStorageI *tdps)
-{
-	free(tdps);
-}
-
-