Context Navigation

source: thirdparty/SZ/sz/src/szd_float.c @ 2c47b73

Revision 2c47b73, 66.3 KB checked in by Hal Finkel <hfinkel@…>, 6 years ago (diff)
more work on adding SZ (latest version)
Property mode set to `100644`

Line
1	/**
2	* @file szd_float.c
3	* @author Sheng Di and Dingwen Tao
4	* @date Aug, 2016
5	* @brief
6	* (C) 2016 by Mathematics and Computer Science (MCS), Argonne National Laboratory.
7	* See COPYRIGHT in top-level directory.
8	*/
9
10	#include <stdlib.h>
11	#include <stdio.h>
12	#include <string.h>
13	#include "szd_float.h"
14	#include "TightDataPointStorageF.h"
15	#include "sz.h"
16	#include "Huffman.h"
17	#include "szd_float_pwr.h"
18	#include "szd_float_ts.h"
19
20	/**
21	*
22	*
23	* @return status SUCCESSFUL (SZ_SCES) or not (other error codes) f
24	* */
25	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)
26	{
27	int status = SZ_SCES;
28	size_t dataLength = computeDataLength(r5,r4,r3,r2,r1);
29
30	//unsigned char* tmpBytes;
31	size_t targetUncompressSize = dataLength <<2; //i.e., *4
32	//tmpSize must be "much" smaller than dataLength
33	size_t i, tmpSize = 8+MetaDataByteLength+exe_params->SZ_SIZE_TYPE;
34	unsigned char* szTmpBytes;
35
36	if(cmpSize!=8+4+MetaDataByteLength && cmpSize!=8+8+MetaDataByteLength) //4,8 means two posibilities of SZ_SIZE_TYPE
37	{
38	int isZlib = isZlibFormat(cmpBytes[0], cmpBytes[1]);
39	if(confparams_dec->szMode!=SZ_TEMPORAL_COMPRESSION)
40	{
41	if(isZlib)
42	confparams_dec->szMode = SZ_BEST_COMPRESSION;
43	else
44	confparams_dec->szMode = SZ_BEST_SPEED;
45	}
46
47	if(confparams_dec->szMode==SZ_BEST_SPEED)
48	{
49	tmpSize = cmpSize;
50	szTmpBytes = cmpBytes;
51	}
52	else if(confparams_dec->szMode==SZ_BEST_COMPRESSION \|\| confparams_dec->szMode==SZ_DEFAULT_COMPRESSION \|\| confparams_dec->szMode==SZ_TEMPORAL_COMPRESSION)
53	{
54	if(targetUncompressSize<MIN_ZLIB_DEC_ALLOMEM_BYTES) //Considering the minimum size
55	targetUncompressSize = MIN_ZLIB_DEC_ALLOMEM_BYTES;
56	tmpSize = zlib_uncompress5(cmpBytes, (unsigned long)cmpSize, &szTmpBytes, (unsigned long)targetUncompressSize+4+MetaDataByteLength+exe_params->SZ_SIZE_TYPE);// (unsigned long)targetUncompressSize+8: consider the total length under lossless compression mode is actually 3+4+1+targetUncompressSize
57	//szTmpBytes = (unsigned char)malloc(sizeof(unsigned char)tmpSize);
58	//memcpy(szTmpBytes, tmpBytes, tmpSize);
59	//free(tmpBytes); //release useless memory
60	}
61	else
62	{
63	printf("Wrong value of confparams_dec->szMode in the double compressed bytes.\n");
64	status = SZ_MERR;
65	return status;
66	}
67	}
68	else
69	szTmpBytes = cmpBytes;
70	//TODO: convert szTmpBytes to data array.
71	TightDataPointStorageF* tdps;
72	int errBoundMode = new_TightDataPointStorageF_fromFlatBytes(&tdps, szTmpBytes, tmpSize);
73
74	//writeByteData(tdps->typeArray, tdps->typeArray_size, "decompress-typebytes.tbt");
75	int dim = computeDimension(r5,r4,r3,r2,r1);
76	int floatSize = sizeof(float);
77	if(tdps->isLossless)
78	{
79	newData = (float)malloc(floatSize*dataLength);
80	if(sysEndianType==BIG_ENDIAN_SYSTEM)
81	{
82	memcpy(newData, szTmpBytes+4+MetaDataByteLength+exe_params->SZ_SIZE_TYPE, dataLengthfloatSize);
83	}
84	else
85	{
86	unsigned char* p = szTmpBytes+4+MetaDataByteLength+exe_params->SZ_SIZE_TYPE;
87	for(i=0;i<dataLength;i++,p+=floatSize)
88	(*newData)[i] = bytesToFloat(p);
89	}
90	}
91	else if (dim == 1)
92	getSnapshotData_float_1D(newData,r1,tdps, errBoundMode);
93	else
94	if (dim == 2)
95	getSnapshotData_float_2D(newData,r2,r1,tdps, errBoundMode);
96	else
97	if (dim == 3)
98	getSnapshotData_float_3D(newData,r3,r2,r1,tdps, errBoundMode);
99	else
100	if (dim == 4)
101	getSnapshotData_float_4D(newData,r4,r3,r2,r1,tdps, errBoundMode);
102	else
103	{
104	printf("Error: currently support only at most 4 dimensions!\n");
105	status = SZ_DERR;
106	}
107	free_TightDataPointStorageF2(tdps);
108	if(confparams_dec->szMode!=SZ_BEST_SPEED && cmpSize!=8+MetaDataByteLength+exe_params->SZ_SIZE_TYPE)
109	free(szTmpBytes);
110	return status;
111	}
112
113	void decompressDataSeries_float_1D(float** data, size_t dataSeriesLength, TightDataPointStorageF* tdps)
114	{
115	updateQuantizationInfo(tdps->intervals);
116	size_t i, j, k = 0, p = 0, l = 0; // k is to track the location of residual_bit
117	// in resiMidBits, p is to track the
118	// byte_index of resiMidBits, l is for
119	// leadNum
120	unsigned char* leadNum;
121	double interval = tdps->realPrecision*2;
122
123	convertByteArray2IntArray_fast_2b(tdps->exactDataNum, tdps->leadNumArray, tdps->leadNumArray_size, &leadNum);
124
125	data = (float)malloc(sizeof(float)*dataSeriesLength);
126
127	int* type = (int)malloc(dataSeriesLengthsizeof(int));
128
129	HuffmanTree* huffmanTree = createHuffmanTree(tdps->stateNum);
130	decode_withTree(huffmanTree, tdps->typeArray, dataSeriesLength, type);
131	SZ_ReleaseHuffman(huffmanTree);
132
133	unsigned char preBytes[4];
134	unsigned char curBytes[4];
135
136	memset(preBytes, 0, 4);
137
138	size_t curByteIndex = 0;
139	int reqBytesLength, resiBitsLength, resiBits;
140	unsigned char leadingNum;
141	float medianValue, exactData, predValue;
142
143	reqBytesLength = tdps->reqLength/8;
144	resiBitsLength = tdps->reqLength%8;
145	medianValue = tdps->medianValue;
146
147	int type_;
148	for (i = 0; i < dataSeriesLength; i++) {
149	type_ = type[i];
150	switch (type_) {
151	case 0:
152	// compute resiBits
153	resiBits = 0;
154	if (resiBitsLength != 0) {
155	int kMod8 = k % 8;
156	int rightMovSteps = getRightMovingSteps(kMod8, resiBitsLength);
157	if (rightMovSteps > 0) {
158	int code = getRightMovingCode(kMod8, resiBitsLength);
159	resiBits = (tdps->residualMidBits[p] & code) >> rightMovSteps;
160	} else if (rightMovSteps < 0) {
161	int code1 = getLeftMovingCode(kMod8);
162	int code2 = getRightMovingCode(kMod8, resiBitsLength);
163	int leftMovSteps = -rightMovSteps;
164	rightMovSteps = 8 - leftMovSteps;
165	resiBits = (tdps->residualMidBits[p] & code1) << leftMovSteps;
166	p++;
167	resiBits = resiBits
168	\| ((tdps->residualMidBits[p] & code2) >> rightMovSteps);
169	} else // rightMovSteps == 0
170	{
171	int code = getRightMovingCode(kMod8, resiBitsLength);
172	resiBits = (tdps->residualMidBits[p] & code);
173	p++;
174	}
175	k += resiBitsLength;
176	}
177
178	// recover the exact data
179	memset(curBytes, 0, 4);
180	leadingNum = leadNum[l++];
181	memcpy(curBytes, preBytes, leadingNum);
182	for (j = leadingNum; j < reqBytesLength; j++)
183	curBytes[j] = tdps->exactMidBytes[curByteIndex++];
184	if (resiBitsLength != 0) {
185	unsigned char resiByte = (unsigned char) (resiBits << (8 - resiBitsLength));
186	curBytes[reqBytesLength] = resiByte;
187	}
188
189	exactData = bytesToFloat(curBytes);
190	(*data)[i] = exactData + medianValue;
191	memcpy(preBytes,curBytes,4);
192	break;
193	default:
194	//predValue = 2 * (data)[i-1] - (data)[i-2];
195	predValue = (*data)[i-1];
196	(data)[i] = predValue + (type_-exe_params->intvRadius)interval;
197	break;
198	}
199	//printf("%.30G\n",(*data)[i]);
200	}
201
202	#ifdef HAVE_TIMECMPR
203	if(confparams_dec->szMode == SZ_TEMPORAL_COMPRESSION)
204	memcpy(multisteps->hist_data, (data), dataSeriesLengthsizeof(float));
205	#endif
206
207	free(leadNum);
208	free(type);
209	return;
210	}
211
212	void decompressDataSeries_float_2D(float** data, size_t r1, size_t r2, TightDataPointStorageF* tdps)
213	{
214	updateQuantizationInfo(tdps->intervals);
215	//printf("tdps->intervals=%d, exe_params->intvRadius=%d\n", tdps->intervals, exe_params->intvRadius);
216
217	size_t j, k = 0, p = 0, l = 0; // k is to track the location of residual_bit
218	// in resiMidBits, p is to track the
219	// byte_index of resiMidBits, l is for
220	// leadNum
221	size_t dataSeriesLength = r1*r2;
222	// printf ("%d %d\n", r1, r2);
223
224	unsigned char* leadNum;
225	double realPrecision = tdps->realPrecision;
226
227	convertByteArray2IntArray_fast_2b(tdps->exactDataNum, tdps->leadNumArray, tdps->leadNumArray_size, &leadNum);
228
229	data = (float)malloc(sizeof(float)*dataSeriesLength);
230
231	int* type = (int)malloc(dataSeriesLengthsizeof(int));
232
233	HuffmanTree* huffmanTree = createHuffmanTree(tdps->stateNum);
234	decode_withTree(huffmanTree, tdps->typeArray, dataSeriesLength, type);
235	SZ_ReleaseHuffman(huffmanTree);
236
237	unsigned char preBytes[4];
238	unsigned char curBytes[4];
239
240	memset(preBytes, 0, 4);
241
242	size_t curByteIndex = 0;
243	int reqBytesLength, resiBitsLength, resiBits;
244	unsigned char leadingNum;
245	float medianValue, exactData;
246	int type_;
247
248	reqBytesLength = tdps->reqLength/8;
249	resiBitsLength = tdps->reqLength%8;
250	medianValue = tdps->medianValue;
251
252	float pred1D, pred2D;
253	size_t ii, jj;
254
255	/* Process Row-0, data 0 */
256
257	// compute resiBits
258	resiBits = 0;
259	if (resiBitsLength != 0) {
260	int kMod8 = k % 8;
261	int rightMovSteps = getRightMovingSteps(kMod8, resiBitsLength);
262	if (rightMovSteps > 0) {
263	int code = getRightMovingCode(kMod8, resiBitsLength);
264	resiBits = (tdps->residualMidBits[p] & code) >> rightMovSteps;
265	} else if (rightMovSteps < 0) {
266	int code1 = getLeftMovingCode(kMod8);
267	int code2 = getRightMovingCode(kMod8, resiBitsLength);
268	int leftMovSteps = -rightMovSteps;
269	rightMovSteps = 8 - leftMovSteps;
270	resiBits = (tdps->residualMidBits[p] & code1) << leftMovSteps;
271	p++;
272	resiBits = resiBits
273	\| ((tdps->residualMidBits[p] & code2) >> rightMovSteps);
274	} else // rightMovSteps == 0
275	{
276	int code = getRightMovingCode(kMod8, resiBitsLength);
277	resiBits = (tdps->residualMidBits[p] & code);
278	p++;
279	}
280	k += resiBitsLength;
281	}
282
283	// recover the exact data
284	memset(curBytes, 0, 4);
285	leadingNum = leadNum[l++];
286	memcpy(curBytes, preBytes, leadingNum);
287	for (j = leadingNum; j < reqBytesLength; j++)
288	curBytes[j] = tdps->exactMidBytes[curByteIndex++];
289	if (resiBitsLength != 0) {
290	unsigned char resiByte = (unsigned char) (resiBits << (8 - resiBitsLength));
291	curBytes[reqBytesLength] = resiByte;
292	}
293
294	exactData = bytesToFloat(curBytes);
295	(*data)[0] = exactData + medianValue;
296	memcpy(preBytes,curBytes,4);
297
298	/* Process Row-0, data 1 */
299	type_ = type[1];
300	if (type_ != 0)
301	{
302	pred1D = (*data)[0];
303	(data)[1] = pred1D + 2 (type_ - exe_params->intvRadius) * realPrecision;
304	}
305	else
306	{
307	// compute resiBits
308	resiBits = 0;
309	if (resiBitsLength != 0) {
310	int kMod8 = k % 8;
311	int rightMovSteps = getRightMovingSteps(kMod8, resiBitsLength);
312	if (rightMovSteps > 0) {
313	int code = getRightMovingCode(kMod8, resiBitsLength);
314	resiBits = (tdps->residualMidBits[p] & code) >> rightMovSteps;
315	} else if (rightMovSteps < 0) {
316	int code1 = getLeftMovingCode(kMod8);
317	int code2 = getRightMovingCode(kMod8, resiBitsLength);
318	int leftMovSteps = -rightMovSteps;
319	rightMovSteps = 8 - leftMovSteps;
320	resiBits = (tdps->residualMidBits[p] & code1) << leftMovSteps;
321	p++;
322	resiBits = resiBits
323	\| ((tdps->residualMidBits[p] & code2) >> rightMovSteps);
324	} else // rightMovSteps == 0
325	{
326	int code = getRightMovingCode(kMod8, resiBitsLength);
327	resiBits = (tdps->residualMidBits[p] & code);
328	p++;
329	}
330	k += resiBitsLength;
331	}
332
333	// recover the exact data
334	memset(curBytes, 0, 4);
335	leadingNum = leadNum[l++];
336	memcpy(curBytes, preBytes, leadingNum);
337	for (j = leadingNum; j < reqBytesLength; j++)
338	curBytes[j] = tdps->exactMidBytes[curByteIndex++];
339	if (resiBitsLength != 0) {
340	unsigned char resiByte = (unsigned char) (resiBits << (8 - resiBitsLength));
341	curBytes[reqBytesLength] = resiByte;
342	}
343
344	exactData = bytesToFloat(curBytes);
345	(*data)[1] = exactData + medianValue;
346	memcpy(preBytes,curBytes,4);
347	}
348
349	/* Process Row-0, data 2 --> data r2-1 */
350	for (jj = 2; jj < r2; jj++)
351	{
352	type_ = type[jj];
353	if (type_ != 0)
354	{
355	pred1D = 2(data)[jj-1] - (*data)[jj-2];
356	(data)[jj] = pred1D + 2 (type_ - exe_params->intvRadius) * realPrecision;
357	}
358	else
359	{
360	// compute resiBits
361	resiBits = 0;
362	if (resiBitsLength != 0) {
363	int kMod8 = k % 8;
364	int rightMovSteps = getRightMovingSteps(kMod8, resiBitsLength);
365	if (rightMovSteps > 0) {
366	int code = getRightMovingCode(kMod8, resiBitsLength);
367	resiBits = (tdps->residualMidBits[p] & code) >> rightMovSteps;
368	} else if (rightMovSteps < 0) {
369	int code1 = getLeftMovingCode(kMod8);
370	int code2 = getRightMovingCode(kMod8, resiBitsLength);
371	int leftMovSteps = -rightMovSteps;
372	rightMovSteps = 8 - leftMovSteps;
373	resiBits = (tdps->residualMidBits[p] & code1) << leftMovSteps;
374	p++;
375	resiBits = resiBits
376	\| ((tdps->residualMidBits[p] & code2) >> rightMovSteps);
377	} else // rightMovSteps == 0
378	{
379	int code = getRightMovingCode(kMod8, resiBitsLength);
380	resiBits = (tdps->residualMidBits[p] & code);
381	p++;
382	}
383	k += resiBitsLength;
384	}
385
386	// recover the exact data
387	memset(curBytes, 0, 4);
388	leadingNum = leadNum[l++];
389	memcpy(curBytes, preBytes, leadingNum);
390	for (j = leadingNum; j < reqBytesLength; j++)
391	curBytes[j] = tdps->exactMidBytes[curByteIndex++];
392	if (resiBitsLength != 0) {
393	unsigned char resiByte = (unsigned char) (resiBits << (8 - resiBitsLength));
394	curBytes[reqBytesLength] = resiByte;
395	}
396
397	exactData = bytesToFloat(curBytes);
398	(*data)[jj] = exactData + medianValue;
399	memcpy(preBytes,curBytes,4);
400	}
401	}
402
403	size_t index;
404	/* Process Row-1 --> Row-r1-1 */
405	for (ii = 1; ii < r1; ii++)
406	{
407	/* Process row-ii data 0 */
408	index = ii*r2;
409
410	type_ = type[index];
411	if (type_ != 0)
412	{
413	pred1D = (*data)[index-r2];
414	(data)[index] = pred1D + 2 (type_ - exe_params->intvRadius) * realPrecision;
415	}
416	else
417	{
418	// compute resiBits
419	resiBits = 0;
420	if (resiBitsLength != 0) {
421	int kMod8 = k % 8;
422	int rightMovSteps = getRightMovingSteps(kMod8, resiBitsLength);
423	if (rightMovSteps > 0) {
424	int code = getRightMovingCode(kMod8, resiBitsLength);
425	resiBits = (tdps->residualMidBits[p] & code) >> rightMovSteps;
426	} else if (rightMovSteps < 0) {
427	int code1 = getLeftMovingCode(kMod8);
428	int code2 = getRightMovingCode(kMod8, resiBitsLength);
429	int leftMovSteps = -rightMovSteps;
430	rightMovSteps = 8 - leftMovSteps;
431	resiBits = (tdps->residualMidBits[p] & code1) << leftMovSteps;
432	p++;
433	resiBits = resiBits
434	\| ((tdps->residualMidBits[p] & code2) >> rightMovSteps);
435	} else // rightMovSteps == 0
436	{
437	int code = getRightMovingCode(kMod8, resiBitsLength);
438	resiBits = (tdps->residualMidBits[p] & code);
439	p++;
440	}
441	k += resiBitsLength;
442	}
443
444	// recover the exact data
445	memset(curBytes, 0, 4);
446	leadingNum = leadNum[l++];
447	memcpy(curBytes, preBytes, leadingNum);
448	for (j = leadingNum; j < reqBytesLength; j++)
449	curBytes[j] = tdps->exactMidBytes[curByteIndex++];
450	if (resiBitsLength != 0) {
451	unsigned char resiByte = (unsigned char) (resiBits << (8 - resiBitsLength));
452	curBytes[reqBytesLength] = resiByte;
453	}
454
455	exactData = bytesToFloat(curBytes);
456	(*data)[index] = exactData + medianValue;
457	memcpy(preBytes,curBytes,4);
458	}
459
460	/* Process row-ii data 1 --> r2-1*/
461	for (jj = 1; jj < r2; jj++)
462	{
463	index = ii*r2+jj;
464	pred2D = (data)[index-1] + (data)[index-r2] - (*data)[index-r2-1];
465
466	type_ = type[index];
467	if (type_ != 0)
468	{
469	(data)[index] = pred2D + 2 (type_ - exe_params->intvRadius) * realPrecision;
470	}
471	else
472	{
473	// compute resiBits
474	resiBits = 0;
475	if (resiBitsLength != 0) {
476	int kMod8 = k % 8;
477	int rightMovSteps = getRightMovingSteps(kMod8, resiBitsLength);
478	if (rightMovSteps > 0) {
479	int code = getRightMovingCode(kMod8, resiBitsLength);
480	resiBits = (tdps->residualMidBits[p] & code) >> rightMovSteps;
481	} else if (rightMovSteps < 0) {
482	int code1 = getLeftMovingCode(kMod8);
483	int code2 = getRightMovingCode(kMod8, resiBitsLength);
484	int leftMovSteps = -rightMovSteps;
485	rightMovSteps = 8 - leftMovSteps;
486	resiBits = (tdps->residualMidBits[p] & code1) << leftMovSteps;
487	p++;
488	resiBits = resiBits
489	\| ((tdps->residualMidBits[p] & code2) >> rightMovSteps);
490	} else // rightMovSteps == 0
491	{
492	int code = getRightMovingCode(kMod8, resiBitsLength);
493	resiBits = (tdps->residualMidBits[p] & code);
494	p++;
495	}
496	k += resiBitsLength;
497	}
498
499	// recover the exact data
500	memset(curBytes, 0, 4);
501	leadingNum = leadNum[l++];
502	memcpy(curBytes, preBytes, leadingNum);
503	for (j = leadingNum; j < reqBytesLength; j++)
504	curBytes[j] = tdps->exactMidBytes[curByteIndex++];
505	if (resiBitsLength != 0) {
506	unsigned char resiByte = (unsigned char) (resiBits << (8 - resiBitsLength));
507	curBytes[reqBytesLength] = resiByte;
508	}
509
510	exactData = bytesToFloat(curBytes);
511	(*data)[index] = exactData + medianValue;
512	memcpy(preBytes,curBytes,4);
513	}
514	}
515	}
516
517	#ifdef HAVE_TIMECMPR
518	if(confparams_dec->szMode == SZ_TEMPORAL_COMPRESSION)
519	memcpy(multisteps->hist_data, (data), dataSeriesLengthsizeof(float));
520	#endif
521
522	free(leadNum);
523	free(type);
524	return;
525	}
526
527	void decompressDataSeries_float_3D(float** data, size_t r1, size_t r2, size_t r3, TightDataPointStorageF* tdps)
528	{
529	updateQuantizationInfo(tdps->intervals);
530	size_t j, k = 0, p = 0, l = 0; // k is to track the location of residual_bit
531	// in resiMidBits, p is to track the
532	// byte_index of resiMidBits, l is for
533	// leadNum
534	size_t dataSeriesLength = r1r2r3;
535	size_t r23 = r2*r3;
536	unsigned char* leadNum;
537	double realPrecision = tdps->realPrecision;
538
539	//TODO
540	convertByteArray2IntArray_fast_2b(tdps->exactDataNum, tdps->leadNumArray, tdps->leadNumArray_size, &leadNum);
541
542	data = (float)malloc(sizeof(float)*dataSeriesLength);
543	int* type = (int)malloc(dataSeriesLengthsizeof(int));
544
545	HuffmanTree* huffmanTree = createHuffmanTree(tdps->stateNum);
546	decode_withTree(huffmanTree, tdps->typeArray, dataSeriesLength, type);
547	SZ_ReleaseHuffman(huffmanTree);
548
549	unsigned char preBytes[4];
550	unsigned char curBytes[4];
551
552	memset(preBytes, 0, 4);
553	size_t curByteIndex = 0;
554	int reqBytesLength, resiBitsLength, resiBits;
555	unsigned char leadingNum;
556	float medianValue, exactData;
557	int type_;
558
559	reqBytesLength = tdps->reqLength/8;
560	resiBitsLength = tdps->reqLength%8;
561	medianValue = tdps->medianValue;
562
563	float pred1D, pred2D, pred3D;
564	size_t ii, jj, kk;
565
566	/////////////////////////// Process layer-0 ///////////////////////////
567	/* Process Row-0 data 0*/
568	// compute resiBits
569	resiBits = 0;
570	if (resiBitsLength != 0) {
571	int kMod8 = k % 8;
572	int rightMovSteps = getRightMovingSteps(kMod8, resiBitsLength);
573	if (rightMovSteps > 0) {
574	int code = getRightMovingCode(kMod8, resiBitsLength);
575	resiBits = (tdps->residualMidBits[p] & code) >> rightMovSteps;
576	} else if (rightMovSteps < 0) {
577	int code1 = getLeftMovingCode(kMod8);
578	int code2 = getRightMovingCode(kMod8, resiBitsLength);
579	int leftMovSteps = -rightMovSteps;
580	rightMovSteps = 8 - leftMovSteps;
581	resiBits = (tdps->residualMidBits[p] & code1) << leftMovSteps;
582	p++;
583	resiBits = resiBits
584	\| ((tdps->residualMidBits[p] & code2) >> rightMovSteps);
585	} else // rightMovSteps == 0
586	{
587	int code = getRightMovingCode(kMod8, resiBitsLength);
588	resiBits = (tdps->residualMidBits[p] & code);
589	p++;
590	}
591	k += resiBitsLength;
592	}
593
594	// recover the exact data
595	memset(curBytes, 0, 4);
596	leadingNum = leadNum[l++];
597	memcpy(curBytes, preBytes, leadingNum);
598	for (j = leadingNum; j < reqBytesLength; j++)
599	curBytes[j] = tdps->exactMidBytes[curByteIndex++];
600	if (resiBitsLength != 0) {
601	unsigned char resiByte = (unsigned char) (resiBits << (8 - resiBitsLength));
602	curBytes[reqBytesLength] = resiByte;
603	}
604	exactData = bytesToFloat(curBytes);
605	(*data)[0] = exactData + medianValue;
606	memcpy(preBytes,curBytes,4);
607
608	/* Process Row-0, data 1 */
609	pred1D = (*data)[0];
610
611	type_ = type[1];
612	if (type_ != 0)
613	{
614	(data)[1] = pred1D + 2 (type_ - exe_params->intvRadius) * realPrecision;
615	}
616	else
617	{
618	// compute resiBits
619	resiBits = 0;
620	if (resiBitsLength != 0) {
621	int kMod8 = k % 8;
622	int rightMovSteps = getRightMovingSteps(kMod8, resiBitsLength);
623	if (rightMovSteps > 0) {
624	int code = getRightMovingCode(kMod8, resiBitsLength);
625	resiBits = (tdps->residualMidBits[p] & code) >> rightMovSteps;
626	} else if (rightMovSteps < 0) {
627	int code1 = getLeftMovingCode(kMod8);
628	int code2 = getRightMovingCode(kMod8, resiBitsLength);
629	int leftMovSteps = -rightMovSteps;
630	rightMovSteps = 8 - leftMovSteps;
631	resiBits = (tdps->residualMidBits[p] & code1) << leftMovSteps;
632	p++;
633	resiBits = resiBits
634	\| ((tdps->residualMidBits[p] & code2) >> rightMovSteps);
635	} else // rightMovSteps == 0
636	{
637	int code = getRightMovingCode(kMod8, resiBitsLength);
638	resiBits = (tdps->residualMidBits[p] & code);
639	p++;
640	}
641	k += resiBitsLength;
642	}
643
644	// recover the exact data
645	memset(curBytes, 0, 4);
646	leadingNum = leadNum[l++];
647	memcpy(curBytes, preBytes, leadingNum);
648	for (j = leadingNum; j < reqBytesLength; j++)
649	curBytes[j] = tdps->exactMidBytes[curByteIndex++];
650	if (resiBitsLength != 0) {
651	unsigned char resiByte = (unsigned char) (resiBits << (8 - resiBitsLength));
652	curBytes[reqBytesLength] = resiByte;
653	}
654
655	exactData = bytesToFloat(curBytes);
656	(*data)[1] = exactData + medianValue;
657	memcpy(preBytes,curBytes,4);
658	}
659	/* Process Row-0, data 2 --> data r3-1 */
660	for (jj = 2; jj < r3; jj++)
661	{
662	pred1D = 2(data)[jj-1] - (*data)[jj-2];
663
664	type_ = type[jj];
665	if (type_ != 0)
666	{
667	(data)[jj] = pred1D + 2 (type_ - exe_params->intvRadius) * realPrecision;
668	}
669	else
670	{
671	// compute resiBits
672	resiBits = 0;
673	if (resiBitsLength != 0) {
674	int kMod8 = k % 8;
675	int rightMovSteps = getRightMovingSteps(kMod8, resiBitsLength);
676	if (rightMovSteps > 0) {
677	int code = getRightMovingCode(kMod8, resiBitsLength);
678	resiBits = (tdps->residualMidBits[p] & code) >> rightMovSteps;
679	} else if (rightMovSteps < 0) {
680	int code1 = getLeftMovingCode(kMod8);
681	int code2 = getRightMovingCode(kMod8, resiBitsLength);
682	int leftMovSteps = -rightMovSteps;
683	rightMovSteps = 8 - leftMovSteps;
684	resiBits = (tdps->residualMidBits[p] & code1) << leftMovSteps;
685	p++;
686	resiBits = resiBits
687	\| ((tdps->residualMidBits[p] & code2) >> rightMovSteps);
688	} else // rightMovSteps == 0
689	{
690	int code = getRightMovingCode(kMod8, resiBitsLength);
691	resiBits = (tdps->residualMidBits[p] & code);
692	p++;
693	}
694	k += resiBitsLength;
695	}
696
697	// recover the exact data
698	memset(curBytes, 0, 4);
699	leadingNum = leadNum[l++];
700	memcpy(curBytes, preBytes, leadingNum);
701	for (j = leadingNum; j < reqBytesLength; j++)
702	curBytes[j] = tdps->exactMidBytes[curByteIndex++];
703	if (resiBitsLength != 0) {
704	unsigned char resiByte = (unsigned char) (resiBits << (8 - resiBitsLength));
705	curBytes[reqBytesLength] = resiByte;
706	}
707
708	exactData = bytesToFloat(curBytes);
709	(*data)[jj] = exactData + medianValue;
710	memcpy(preBytes,curBytes,4);
711	}
712	}
713
714	size_t index;
715	/* Process Row-1 --> Row-r2-1 */
716	for (ii = 1; ii < r2; ii++)
717	{
718	/* Process row-ii data 0 */
719	index = ii*r3;
720	pred1D = (*data)[index-r3];
721
722	type_ = type[index];
723	if (type_ != 0)
724	{
725	(data)[index] = pred1D + 2 (type_ - exe_params->intvRadius) * realPrecision;
726	}
727	else
728	{
729	// compute resiBits
730	resiBits = 0;
731	if (resiBitsLength != 0) {
732	int kMod8 = k % 8;
733	int rightMovSteps = getRightMovingSteps(kMod8, resiBitsLength);
734	if (rightMovSteps > 0) {
735	int code = getRightMovingCode(kMod8, resiBitsLength);
736	resiBits = (tdps->residualMidBits[p] & code) >> rightMovSteps;
737	} else if (rightMovSteps < 0) {
738	int code1 = getLeftMovingCode(kMod8);
739	int code2 = getRightMovingCode(kMod8, resiBitsLength);
740	int leftMovSteps = -rightMovSteps;
741	rightMovSteps = 8 - leftMovSteps;
742	resiBits = (tdps->residualMidBits[p] & code1) << leftMovSteps;
743	p++;
744	resiBits = resiBits
745	\| ((tdps->residualMidBits[p] & code2) >> rightMovSteps);
746	} else // rightMovSteps == 0
747	{
748	int code = getRightMovingCode(kMod8, resiBitsLength);
749	resiBits = (tdps->residualMidBits[p] & code);
750	p++;
751	}
752	k += resiBitsLength;
753	}
754
755	// recover the exact data
756	memset(curBytes, 0, 4);
757	leadingNum = leadNum[l++];
758	memcpy(curBytes, preBytes, leadingNum);
759	for (j = leadingNum; j < reqBytesLength; j++)
760	curBytes[j] = tdps->exactMidBytes[curByteIndex++];
761	if (resiBitsLength != 0) {
762	unsigned char resiByte = (unsigned char) (resiBits << (8 - resiBitsLength));
763	curBytes[reqBytesLength] = resiByte;
764	}
765
766	exactData = bytesToFloat(curBytes);
767	(*data)[index] = exactData + medianValue;
768	memcpy(preBytes,curBytes,4);
769	}
770
771	/* Process row-ii data 1 --> r3-1*/
772	for (jj = 1; jj < r3; jj++)
773	{
774	index = ii*r3+jj;
775	pred2D = (data)[index-1] + (data)[index-r3] - (*data)[index-r3-1];
776
777	type_ = type[index];
778	if (type_ != 0)
779	{
780	(data)[index] = pred2D + 2 (type_ - exe_params->intvRadius) * realPrecision;
781	}
782	else
783	{
784	// compute resiBits
785	resiBits = 0;
786	if (resiBitsLength != 0) {
787	int kMod8 = k % 8;
788	int rightMovSteps = getRightMovingSteps(kMod8, resiBitsLength);
789	if (rightMovSteps > 0) {
790	int code = getRightMovingCode(kMod8, resiBitsLength);
791	resiBits = (tdps->residualMidBits[p] & code) >> rightMovSteps;
792	} else if (rightMovSteps < 0) {
793	int code1 = getLeftMovingCode(kMod8);
794	int code2 = getRightMovingCode(kMod8, resiBitsLength);
795	int leftMovSteps = -rightMovSteps;
796	rightMovSteps = 8 - leftMovSteps;
797	resiBits = (tdps->residualMidBits[p] & code1) << leftMovSteps;
798	p++;
799	resiBits = resiBits
800	\| ((tdps->residualMidBits[p] & code2) >> rightMovSteps);
801	} else // rightMovSteps == 0
802	{
803	int code = getRightMovingCode(kMod8, resiBitsLength);
804	resiBits = (tdps->residualMidBits[p] & code);
805	p++;
806	}
807	k += resiBitsLength;
808	}
809
810	// recover the exact data
811	memset(curBytes, 0, 4);
812	leadingNum = leadNum[l++];
813	memcpy(curBytes, preBytes, leadingNum);
814	for (j = leadingNum; j < reqBytesLength; j++)
815	curBytes[j] = tdps->exactMidBytes[curByteIndex++];
816	if (resiBitsLength != 0) {
817	unsigned char resiByte = (unsigned char) (resiBits << (8 - resiBitsLength));
818	curBytes[reqBytesLength] = resiByte;
819	}
820
821	exactData = bytesToFloat(curBytes);
822	(*data)[index] = exactData + medianValue;
823	memcpy(preBytes,curBytes,4);
824	}
825	}
826	}
827
828	/////////////////////////// Process layer-1 --> layer-r1-1 ///////////////////////////
829
830	for (kk = 1; kk < r1; kk++)
831	{
832	/* Process Row-0 data 0*/
833	index = kk*r23;
834	pred1D = (*data)[index-r23];
835
836	type_ = type[index];
837	if (type_ != 0)
838	{
839	(data)[index] = pred1D + 2 (type_ - exe_params->intvRadius) * realPrecision;
840	}
841	else
842	{
843	// compute resiBits
844	resiBits = 0;
845	if (resiBitsLength != 0) {
846	int kMod8 = k % 8;
847	int rightMovSteps = getRightMovingSteps(kMod8, resiBitsLength);
848	if (rightMovSteps > 0) {
849	int code = getRightMovingCode(kMod8, resiBitsLength);
850	resiBits = (tdps->residualMidBits[p] & code) >> rightMovSteps;
851	} else if (rightMovSteps < 0) {
852	int code1 = getLeftMovingCode(kMod8);
853	int code2 = getRightMovingCode(kMod8, resiBitsLength);
854	int leftMovSteps = -rightMovSteps;
855	rightMovSteps = 8 - leftMovSteps;
856	resiBits = (tdps->residualMidBits[p] & code1) << leftMovSteps;
857	p++;
858	resiBits = resiBits
859	\| ((tdps->residualMidBits[p] & code2) >> rightMovSteps);
860	} else // rightMovSteps == 0
861	{
862	int code = getRightMovingCode(kMod8, resiBitsLength);
863	resiBits = (tdps->residualMidBits[p] & code);
864	p++;
865	}
866	k += resiBitsLength;
867	}
868
869	// recover the exact data
870	memset(curBytes, 0, 4);
871	leadingNum = leadNum[l++];
872	memcpy(curBytes, preBytes, leadingNum);
873	for (j = leadingNum; j < reqBytesLength; j++)
874	curBytes[j] = tdps->exactMidBytes[curByteIndex++];
875	if (resiBitsLength != 0) {
876	unsigned char resiByte = (unsigned char) (resiBits << (8 - resiBitsLength));
877	curBytes[reqBytesLength] = resiByte;
878	}
879
880	exactData = bytesToFloat(curBytes);
881	(*data)[index] = exactData + medianValue;
882	memcpy(preBytes,curBytes,4);
883	}
884
885	/* Process Row-0 data 1 --> data r3-1 */
886	for (jj = 1; jj < r3; jj++)
887	{
888	index = kk*r23+jj;
889	pred2D = (data)[index-1] + (data)[index-r23] - (*data)[index-r23-1];
890
891	type_ = type[index];
892	if (type_ != 0)
893	{
894	(data)[index] = pred2D + 2 (type_ - exe_params->intvRadius) * realPrecision;
895	}
896	else
897	{
898	// compute resiBits
899	resiBits = 0;
900	if (resiBitsLength != 0) {
901	int kMod8 = k % 8;
902	int rightMovSteps = getRightMovingSteps(kMod8, resiBitsLength);
903	if (rightMovSteps > 0) {
904	int code = getRightMovingCode(kMod8, resiBitsLength);
905	resiBits = (tdps->residualMidBits[p] & code) >> rightMovSteps;
906	} else if (rightMovSteps < 0) {
907	int code1 = getLeftMovingCode(kMod8);
908	int code2 = getRightMovingCode(kMod8, resiBitsLength);
909	int leftMovSteps = -rightMovSteps;
910	rightMovSteps = 8 - leftMovSteps;
911	resiBits = (tdps->residualMidBits[p] & code1) << leftMovSteps;
912	p++;
913	resiBits = resiBits
914	\| ((tdps->residualMidBits[p] & code2) >> rightMovSteps);
915	} else // rightMovSteps == 0
916	{
917	int code = getRightMovingCode(kMod8, resiBitsLength);
918	resiBits = (tdps->residualMidBits[p] & code);
919	p++;
920	}
921	k += resiBitsLength;
922	}
923
924	// recover the exact data
925	memset(curBytes, 0, 4);
926	leadingNum = leadNum[l++];
927	memcpy(curBytes, preBytes, leadingNum);
928	for (j = leadingNum; j < reqBytesLength; j++)
929	curBytes[j] = tdps->exactMidBytes[curByteIndex++];
930	if (resiBitsLength != 0) {
931	unsigned char resiByte = (unsigned char) (resiBits << (8 - resiBitsLength));
932	curBytes[reqBytesLength] = resiByte;
933	}
934
935	exactData = bytesToFloat(curBytes);
936	(*data)[index] = exactData + medianValue;
937	memcpy(preBytes,curBytes,4);
938	}
939	}
940
941	/* Process Row-1 --> Row-r2-1 */
942	for (ii = 1; ii < r2; ii++)
943	{
944	/* Process Row-i data 0 */
945	index = kkr23 + iir3;
946	pred2D = (data)[index-r3] + (data)[index-r23] - (*data)[index-r23-r3];
947
948	type_ = type[index];
949	if (type_ != 0)
950	{
951	(data)[index] = pred2D + 2 (type_ - exe_params->intvRadius) * realPrecision;
952	}
953	else
954	{
955	// compute resiBits
956	resiBits = 0;
957	if (resiBitsLength != 0) {
958	int kMod8 = k % 8;
959	int rightMovSteps = getRightMovingSteps(kMod8, resiBitsLength);
960	if (rightMovSteps > 0) {
961	int code = getRightMovingCode(kMod8, resiBitsLength);
962	resiBits = (tdps->residualMidBits[p] & code) >> rightMovSteps;
963	} else if (rightMovSteps < 0) {
964	int code1 = getLeftMovingCode(kMod8);
965	int code2 = getRightMovingCode(kMod8, resiBitsLength);
966	int leftMovSteps = -rightMovSteps;
967	rightMovSteps = 8 - leftMovSteps;
968	resiBits = (tdps->residualMidBits[p] & code1) << leftMovSteps;
969	p++;
970	resiBits = resiBits
971	\| ((tdps->residualMidBits[p] & code2) >> rightMovSteps);
972	} else // rightMovSteps == 0
973	{
974	int code = getRightMovingCode(kMod8, resiBitsLength);
975	resiBits = (tdps->residualMidBits[p] & code);
976	p++;
977	}
978	k += resiBitsLength;
979	}
980
981	// recover the exact data
982	memset(curBytes, 0, 4);
983	leadingNum = leadNum[l++];
984	memcpy(curBytes, preBytes, leadingNum);
985	for (j = leadingNum; j < reqBytesLength; j++)
986	curBytes[j] = tdps->exactMidBytes[curByteIndex++];
987	if (resiBitsLength != 0) {
988	unsigned char resiByte = (unsigned char) (resiBits << (8 - resiBitsLength));
989	curBytes[reqBytesLength] = resiByte;
990	}
991
992	exactData = bytesToFloat(curBytes);
993	(*data)[index] = exactData + medianValue;
994	memcpy(preBytes,curBytes,4);
995	}
996
997	/* Process Row-i data 1 --> data r3-1 */
998	for (jj = 1; jj < r3; jj++)
999	{
1000	index = kkr23 + iir3 + jj;
1001	pred3D = (data)[index-1] + (data)[index-r3] + (*data)[index-r23]
1002	- (data)[index-r3-1] - (data)[index-r23-r3] - (data)[index-r23-1] + (data)[index-r23-r3-1];
1003
1004	type_ = type[index];
1005	if (type_ != 0)
1006	{
1007	(data)[index] = pred3D + 2 (type_ - exe_params->intvRadius) * realPrecision;
1008	}
1009	else
1010	{
1011	// compute resiBits
1012	resiBits = 0;
1013	if (resiBitsLength != 0) {
1014	int kMod8 = k % 8;
1015	int rightMovSteps = getRightMovingSteps(kMod8, resiBitsLength);
1016	if (rightMovSteps > 0) {
1017	int code = getRightMovingCode(kMod8, resiBitsLength);
1018	resiBits = (tdps->residualMidBits[p] & code) >> rightMovSteps;
1019	} else if (rightMovSteps < 0) {
1020	int code1 = getLeftMovingCode(kMod8);
1021	int code2 = getRightMovingCode(kMod8, resiBitsLength);
1022	int leftMovSteps = -rightMovSteps;
1023	rightMovSteps = 8 - leftMovSteps;
1024	resiBits = (tdps->residualMidBits[p] & code1) << leftMovSteps;
1025	p++;
1026	resiBits = resiBits
1027	\| ((tdps->residualMidBits[p] & code2) >> rightMovSteps);
1028	} else // rightMovSteps == 0
1029	{
1030	int code = getRightMovingCode(kMod8, resiBitsLength);
1031	resiBits = (tdps->residualMidBits[p] & code);
1032	p++;
1033	}
1034	k += resiBitsLength;
1035	}
1036
1037	// recover the exact data
1038	memset(curBytes, 0, 4);
1039	leadingNum = leadNum[l++];
1040	memcpy(curBytes, preBytes, leadingNum);
1041	for (j = leadingNum; j < reqBytesLength; j++)
1042	curBytes[j] = tdps->exactMidBytes[curByteIndex++];
1043	if (resiBitsLength != 0) {
1044	unsigned char resiByte = (unsigned char) (resiBits << (8 - resiBitsLength));
1045	curBytes[reqBytesLength] = resiByte;
1046	}
1047
1048	exactData = bytesToFloat(curBytes);
1049	(*data)[index] = exactData + medianValue;
1050	memcpy(preBytes,curBytes,4);
1051	}
1052	}
1053	}
1054	}
1055
1056	#ifdef HAVE_TIMECMPR
1057	if(confparams_dec->szMode == SZ_TEMPORAL_COMPRESSION)
1058	memcpy(multisteps->hist_data, (data), dataSeriesLengthsizeof(float));
1059	#endif
1060
1061	free(leadNum);
1062	free(type);
1063	return;
1064	}
1065
1066
1067	void decompressDataSeries_float_4D(float** data, size_t r1, size_t r2, size_t r3, size_t r4, TightDataPointStorageF* tdps)
1068	{
1069	updateQuantizationInfo(tdps->intervals);
1070	size_t j, k = 0, p = 0, l = 0; // k is to track the location of residual_bit
1071	// in resiMidBits, p is to track the
1072	// byte_index of resiMidBits, l is for
1073	// leadNum
1074	size_t dataSeriesLength = r1r2r3*r4;
1075	size_t r234 = r2r3r4;
1076	size_t r34 = r3*r4;
1077	// printf ("%d %d %d %d\n", r1, r2, r3, r4);
1078	unsigned char* leadNum;
1079	double realPrecision = tdps->realPrecision;
1080
1081	convertByteArray2IntArray_fast_2b(tdps->exactDataNum, tdps->leadNumArray, tdps->leadNumArray_size, &leadNum);
1082
1083	data = (float)malloc(sizeof(float)*dataSeriesLength);
1084	int* type = (int)malloc(dataSeriesLengthsizeof(int));
1085
1086	HuffmanTree* huffmanTree = createHuffmanTree(tdps->stateNum);
1087	decode_withTree(huffmanTree, tdps->typeArray, dataSeriesLength, type);
1088	SZ_ReleaseHuffman(huffmanTree);
1089
1090	unsigned char preBytes[4];
1091	unsigned char curBytes[4];
1092
1093	memset(preBytes, 0, 4);
1094	size_t curByteIndex = 0;
1095	int reqBytesLength, resiBitsLength, resiBits;
1096	unsigned char leadingNum;
1097	float medianValue, exactData;
1098	int type_;
1099
1100	reqBytesLength = tdps->reqLength/8;
1101	resiBitsLength = tdps->reqLength%8;
1102	medianValue = tdps->medianValue;
1103
1104	float pred1D, pred2D, pred3D;
1105	size_t ii, jj, kk, ll;
1106	size_t index;
1107
1108	for (ll = 0; ll < r1; ll++)
1109	{
1110
1111	/////////////////////////// Process layer-0 ///////////////////////////
1112	/* Process Row-0 data 0*/
1113	index = ll*r234;
1114
1115	// compute resiBits
1116	resiBits = 0;
1117	if (resiBitsLength != 0) {
1118	int kMod8 = k % 8;
1119	int rightMovSteps = getRightMovingSteps(kMod8, resiBitsLength);
1120	if (rightMovSteps > 0) {
1121	int code = getRightMovingCode(kMod8, resiBitsLength);
1122	resiBits = (tdps->residualMidBits[p] & code) >> rightMovSteps;
1123	} else if (rightMovSteps < 0) {
1124	int code1 = getLeftMovingCode(kMod8);
1125	int code2 = getRightMovingCode(kMod8, resiBitsLength);
1126	int leftMovSteps = -rightMovSteps;
1127	rightMovSteps = 8 - leftMovSteps;
1128	resiBits = (tdps->residualMidBits[p] & code1) << leftMovSteps;
1129	p++;
1130	resiBits = resiBits
1131	\| ((tdps->residualMidBits[p] & code2) >> rightMovSteps);
1132	} else // rightMovSteps == 0
1133	{
1134	int code = getRightMovingCode(kMod8, resiBitsLength);
1135	resiBits = (tdps->residualMidBits[p] & code);
1136	p++;
1137	}
1138	k += resiBitsLength;
1139	}
1140
1141	// recover the exact data
1142	memset(curBytes, 0, 4);
1143	leadingNum = leadNum[l++];
1144	memcpy(curBytes, preBytes, leadingNum);
1145	for (j = leadingNum; j < reqBytesLength; j++)
1146	curBytes[j] = tdps->exactMidBytes[curByteIndex++];
1147	if (resiBitsLength != 0) {
1148	unsigned char resiByte = (unsigned char) (resiBits << (8 - resiBitsLength));
1149	curBytes[reqBytesLength] = resiByte;
1150	}
1151	exactData = bytesToFloat(curBytes);
1152	(*data)[index] = exactData + medianValue;
1153	memcpy(preBytes,curBytes,4);
1154
1155	/* Process Row-0, data 1 */
1156	index = ll*r234+1;
1157
1158	pred1D = (*data)[index-1];
1159
1160	type_ = type[index];
1161	if (type_ != 0)
1162	{
1163	(data)[index] = pred1D + 2 (type_ - exe_params->intvRadius) * realPrecision;
1164	}
1165	else
1166	{
1167	// compute resiBits
1168	resiBits = 0;
1169	if (resiBitsLength != 0) {
1170	int kMod8 = k % 8;
1171	int rightMovSteps = getRightMovingSteps(kMod8, resiBitsLength);
1172	if (rightMovSteps > 0) {
1173	int code = getRightMovingCode(kMod8, resiBitsLength);
1174	resiBits = (tdps->residualMidBits[p] & code) >> rightMovSteps;
1175	} else if (rightMovSteps < 0) {
1176	int code1 = getLeftMovingCode(kMod8);
1177	int code2 = getRightMovingCode(kMod8, resiBitsLength);
1178	int leftMovSteps = -rightMovSteps;
1179	rightMovSteps = 8 - leftMovSteps;
1180	resiBits = (tdps->residualMidBits[p] & code1) << leftMovSteps;
1181	p++;
1182	resiBits = resiBits
1183	\| ((tdps->residualMidBits[p] & code2) >> rightMovSteps);
1184	} else // rightMovSteps == 0
1185	{
1186	int code = getRightMovingCode(kMod8, resiBitsLength);
1187	resiBits = (tdps->residualMidBits[p] & code);
1188	p++;
1189	}
1190	k += resiBitsLength;
1191	}
1192
1193	// recover the exact data
1194	memset(curBytes, 0, 4);
1195	leadingNum = leadNum[l++];
1196	memcpy(curBytes, preBytes, leadingNum);
1197	for (j = leadingNum; j < reqBytesLength; j++)
1198	curBytes[j] = tdps->exactMidBytes[curByteIndex++];
1199	if (resiBitsLength != 0) {
1200	unsigned char resiByte = (unsigned char) (resiBits << (8 - resiBitsLength));
1201	curBytes[reqBytesLength] = resiByte;
1202	}
1203
1204	exactData = bytesToFloat(curBytes);
1205	(*data)[index] = exactData + medianValue;
1206	memcpy(preBytes,curBytes,4);
1207	}
1208
1209	/* Process Row-0, data 2 --> data r4-1 */
1210	for (jj = 2; jj < r4; jj++)
1211	{
1212	index = ll*r234+jj;
1213
1214	pred1D = 2(data)[index-1] - (*data)[index-2];
1215
1216	type_ = type[index];
1217	if (type_ != 0)
1218	{
1219	(data)[index] = pred1D + 2 (type_ - exe_params->intvRadius) * realPrecision;
1220	}
1221	else
1222	{
1223	// compute resiBits
1224	resiBits = 0;
1225	if (resiBitsLength != 0) {
1226	int kMod8 = k % 8;
1227	int rightMovSteps = getRightMovingSteps(kMod8, resiBitsLength);
1228	if (rightMovSteps > 0) {
1229	int code = getRightMovingCode(kMod8, resiBitsLength);
1230	resiBits = (tdps->residualMidBits[p] & code) >> rightMovSteps;
1231	} else if (rightMovSteps < 0) {
1232	int code1 = getLeftMovingCode(kMod8);
1233	int code2 = getRightMovingCode(kMod8, resiBitsLength);
1234	int leftMovSteps = -rightMovSteps;
1235	rightMovSteps = 8 - leftMovSteps;
1236	resiBits = (tdps->residualMidBits[p] & code1) << leftMovSteps;
1237	p++;
1238	resiBits = resiBits
1239	\| ((tdps->residualMidBits[p] & code2) >> rightMovSteps);
1240	} else // rightMovSteps == 0
1241	{
1242	int code = getRightMovingCode(kMod8, resiBitsLength);
1243	resiBits = (tdps->residualMidBits[p] & code);
1244	p++;
1245	}
1246	k += resiBitsLength;
1247	}
1248
1249	// recover the exact data
1250	memset(curBytes, 0, 4);
1251	leadingNum = leadNum[l++];
1252	memcpy(curBytes, preBytes, leadingNum);
1253	for (j = leadingNum; j < reqBytesLength; j++)
1254	curBytes[j] = tdps->exactMidBytes[curByteIndex++];
1255	if (resiBitsLength != 0) {
1256	unsigned char resiByte = (unsigned char) (resiBits << (8 - resiBitsLength));
1257	curBytes[reqBytesLength] = resiByte;
1258	}
1259
1260	exactData = bytesToFloat(curBytes);
1261	(*data)[index] = exactData + medianValue;
1262	memcpy(preBytes,curBytes,4);
1263	}
1264	}
1265
1266	/* Process Row-1 --> Row-r3-1 */
1267	for (ii = 1; ii < r3; ii++)
1268	{
1269	/* Process row-ii data 0 */
1270	index = llr234+iir4;
1271
1272	pred1D = (*data)[index-r4];
1273
1274	type_ = type[index];
1275	if (type_ != 0)
1276	{
1277	(data)[index] = pred1D + 2 (type_ - exe_params->intvRadius) * realPrecision;
1278	}
1279	else
1280	{
1281	// compute resiBits
1282	resiBits = 0;
1283	if (resiBitsLength != 0) {
1284	int kMod8 = k % 8;
1285	int rightMovSteps = getRightMovingSteps(kMod8, resiBitsLength);
1286	if (rightMovSteps > 0) {
1287	int code = getRightMovingCode(kMod8, resiBitsLength);
1288	resiBits = (tdps->residualMidBits[p] & code) >> rightMovSteps;
1289	} else if (rightMovSteps < 0) {
1290	int code1 = getLeftMovingCode(kMod8);
1291	int code2 = getRightMovingCode(kMod8, resiBitsLength);
1292	int leftMovSteps = -rightMovSteps;
1293	rightMovSteps = 8 - leftMovSteps;
1294	resiBits = (tdps->residualMidBits[p] & code1) << leftMovSteps;
1295	p++;
1296	resiBits = resiBits
1297	\| ((tdps->residualMidBits[p] & code2) >> rightMovSteps);
1298	} else // rightMovSteps == 0
1299	{
1300	int code = getRightMovingCode(kMod8, resiBitsLength);
1301	resiBits = (tdps->residualMidBits[p] & code);
1302	p++;
1303	}
1304	k += resiBitsLength;
1305	}
1306
1307	// recover the exact data
1308	memset(curBytes, 0, 4);
1309	leadingNum = leadNum[l++];
1310	memcpy(curBytes, preBytes, leadingNum);
1311	for (j = leadingNum; j < reqBytesLength; j++)
1312	curBytes[j] = tdps->exactMidBytes[curByteIndex++];
1313	if (resiBitsLength != 0) {
1314	unsigned char resiByte = (unsigned char) (resiBits << (8 - resiBitsLength));
1315	curBytes[reqBytesLength] = resiByte;
1316	}
1317
1318	exactData = bytesToFloat(curBytes);
1319	(*data)[index] = exactData + medianValue;
1320	memcpy(preBytes,curBytes,4);
1321	}
1322
1323	/* Process row-ii data 1 --> r4-1*/
1324	for (jj = 1; jj < r4; jj++)
1325	{
1326	index = llr234+iir4+jj;
1327
1328	pred2D = (data)[index-1] + (data)[index-r4] - (*data)[index-r4-1];
1329
1330	type_ = type[index];
1331	if (type_ != 0)
1332	{
1333	(data)[index] = pred2D + 2 (type_ - exe_params->intvRadius) * realPrecision;
1334	}
1335	else
1336	{
1337	// compute resiBits
1338	resiBits = 0;
1339	if (resiBitsLength != 0) {
1340	int kMod8 = k % 8;
1341	int rightMovSteps = getRightMovingSteps(kMod8, resiBitsLength);
1342	if (rightMovSteps > 0) {
1343	int code = getRightMovingCode(kMod8, resiBitsLength);
1344	resiBits = (tdps->residualMidBits[p] & code) >> rightMovSteps;
1345	} else if (rightMovSteps < 0) {
1346	int code1 = getLeftMovingCode(kMod8);
1347	int code2 = getRightMovingCode(kMod8, resiBitsLength);
1348	int leftMovSteps = -rightMovSteps;
1349	rightMovSteps = 8 - leftMovSteps;
1350	resiBits = (tdps->residualMidBits[p] & code1) << leftMovSteps;
1351	p++;
1352	resiBits = resiBits
1353	\| ((tdps->residualMidBits[p] & code2) >> rightMovSteps);
1354	} else // rightMovSteps == 0
1355	{
1356	int code = getRightMovingCode(kMod8, resiBitsLength);
1357	resiBits = (tdps->residualMidBits[p] & code);
1358	p++;
1359	}
1360	k += resiBitsLength;
1361	}
1362
1363	// recover the exact data
1364	memset(curBytes, 0, 4);
1365	leadingNum = leadNum[l++];
1366	memcpy(curBytes, preBytes, leadingNum);
1367	for (j = leadingNum; j < reqBytesLength; j++)
1368	curBytes[j] = tdps->exactMidBytes[curByteIndex++];
1369	if (resiBitsLength != 0) {
1370	unsigned char resiByte = (unsigned char) (resiBits << (8 - resiBitsLength));
1371	curBytes[reqBytesLength] = resiByte;
1372	}
1373
1374	exactData = bytesToFloat(curBytes);
1375	(*data)[index] = exactData + medianValue;
1376	memcpy(preBytes,curBytes,4);
1377	}
1378	}
1379	}
1380
1381	/////////////////////////// Process layer-1 --> layer-r2-1 ///////////////////////////
1382
1383	for (kk = 1; kk < r2; kk++)
1384	{
1385	/* Process Row-0 data 0*/
1386	index = llr234+kkr34;
1387
1388	pred1D = (*data)[index-r34];
1389
1390	type_ = type[index];
1391	if (type_ != 0)
1392	{
1393	(data)[index] = pred1D + 2 (type_ - exe_params->intvRadius) * realPrecision;
1394	}
1395	else
1396	{
1397	// compute resiBits
1398	resiBits = 0;
1399	if (resiBitsLength != 0) {
1400	int kMod8 = k % 8;
1401	int rightMovSteps = getRightMovingSteps(kMod8, resiBitsLength);
1402	if (rightMovSteps > 0) {
1403	int code = getRightMovingCode(kMod8, resiBitsLength);
1404	resiBits = (tdps->residualMidBits[p] & code) >> rightMovSteps;
1405	} else if (rightMovSteps < 0) {
1406	int code1 = getLeftMovingCode(kMod8);
1407	int code2 = getRightMovingCode(kMod8, resiBitsLength);
1408	int leftMovSteps = -rightMovSteps;
1409	rightMovSteps = 8 - leftMovSteps;
1410	resiBits = (tdps->residualMidBits[p] & code1) << leftMovSteps;
1411	p++;
1412	resiBits = resiBits
1413	\| ((tdps->residualMidBits[p] & code2) >> rightMovSteps);
1414	} else // rightMovSteps == 0
1415	{
1416	int code = getRightMovingCode(kMod8, resiBitsLength);
1417	resiBits = (tdps->residualMidBits[p] & code);
1418	p++;
1419	}
1420	k += resiBitsLength;
1421	}
1422
1423	// recover the exact data
1424	memset(curBytes, 0, 4);
1425	leadingNum = leadNum[l++];
1426	memcpy(curBytes, preBytes, leadingNum);
1427	for (j = leadingNum; j < reqBytesLength; j++)
1428	curBytes[j] = tdps->exactMidBytes[curByteIndex++];
1429	if (resiBitsLength != 0) {
1430	unsigned char resiByte = (unsigned char) (resiBits << (8 - resiBitsLength));
1431	curBytes[reqBytesLength] = resiByte;
1432	}
1433
1434	exactData = bytesToFloat(curBytes);
1435	(*data)[index] = exactData + medianValue;
1436	memcpy(preBytes,curBytes,4);
1437	}
1438
1439	/* Process Row-0 data 1 --> data r4-1 */
1440	for (jj = 1; jj < r4; jj++)
1441	{
1442	index = llr234+kkr34+jj;
1443
1444	pred2D = (data)[index-1] + (data)[index-r34] - (*data)[index-r34-1];
1445
1446	type_ = type[index];
1447	if (type_ != 0)
1448	{
1449	(data)[index] = pred2D + 2 (type_ - exe_params->intvRadius) * realPrecision;
1450	}
1451	else
1452	{
1453	// compute resiBits
1454	resiBits = 0;
1455	if (resiBitsLength != 0) {
1456	int kMod8 = k % 8;
1457	int rightMovSteps = getRightMovingSteps(kMod8, resiBitsLength);
1458	if (rightMovSteps > 0) {
1459	int code = getRightMovingCode(kMod8, resiBitsLength);
1460	resiBits = (tdps->residualMidBits[p] & code) >> rightMovSteps;
1461	} else if (rightMovSteps < 0) {
1462	int code1 = getLeftMovingCode(kMod8);
1463	int code2 = getRightMovingCode(kMod8, resiBitsLength);
1464	int leftMovSteps = -rightMovSteps;
1465	rightMovSteps = 8 - leftMovSteps;
1466	resiBits = (tdps->residualMidBits[p] & code1) << leftMovSteps;
1467	p++;
1468	resiBits = resiBits
1469	\| ((tdps->residualMidBits[p] & code2) >> rightMovSteps);
1470	} else // rightMovSteps == 0
1471	{
1472	int code = getRightMovingCode(kMod8, resiBitsLength);
1473	resiBits = (tdps->residualMidBits[p] & code);
1474	p++;
1475	}
1476	k += resiBitsLength;
1477	}
1478
1479	// recover the exact data
1480	memset(curBytes, 0, 4);
1481	leadingNum = leadNum[l++];
1482	memcpy(curBytes, preBytes, leadingNum);
1483	for (j = leadingNum; j < reqBytesLength; j++)
1484	curBytes[j] = tdps->exactMidBytes[curByteIndex++];
1485	if (resiBitsLength != 0) {
1486	unsigned char resiByte = (unsigned char) (resiBits << (8 - resiBitsLength));
1487	curBytes[reqBytesLength] = resiByte;
1488	}
1489
1490	exactData = bytesToFloat(curBytes);
1491	(*data)[index] = exactData + medianValue;
1492	memcpy(preBytes,curBytes,4);
1493	}
1494	}
1495
1496	/* Process Row-1 --> Row-r3-1 */
1497	for (ii = 1; ii < r3; ii++)
1498	{
1499	/* Process Row-i data 0 */
1500	index = llr234+kkr34+ii*r4;
1501
1502	pred2D = (data)[index-r4] + (data)[index-r34] - (*data)[index-r34-r4];
1503
1504	type_ = type[index];
1505	if (type_ != 0)
1506	{
1507	(data)[index] = pred2D + 2 (type_ - exe_params->intvRadius) * realPrecision;
1508	}
1509	else
1510	{
1511	// compute resiBits
1512	resiBits = 0;
1513	if (resiBitsLength != 0) {
1514	int kMod8 = k % 8;
1515	int rightMovSteps = getRightMovingSteps(kMod8, resiBitsLength);
1516	if (rightMovSteps > 0) {
1517	int code = getRightMovingCode(kMod8, resiBitsLength);
1518	resiBits = (tdps->residualMidBits[p] & code) >> rightMovSteps;
1519	} else if (rightMovSteps < 0) {
1520	int code1 = getLeftMovingCode(kMod8);
1521	int code2 = getRightMovingCode(kMod8, resiBitsLength);
1522	int leftMovSteps = -rightMovSteps;
1523	rightMovSteps = 8 - leftMovSteps;
1524	resiBits = (tdps->residualMidBits[p] & code1) << leftMovSteps;
1525	p++;
1526	resiBits = resiBits
1527	\| ((tdps->residualMidBits[p] & code2) >> rightMovSteps);
1528	} else // rightMovSteps == 0
1529	{
1530	int code = getRightMovingCode(kMod8, resiBitsLength);
1531	resiBits = (tdps->residualMidBits[p] & code);
1532	p++;
1533	}
1534	k += resiBitsLength;
1535	}
1536
1537	// recover the exact data
1538	memset(curBytes, 0, 4);
1539	leadingNum = leadNum[l++];
1540	memcpy(curBytes, preBytes, leadingNum);
1541	for (j = leadingNum; j < reqBytesLength; j++)
1542	curBytes[j] = tdps->exactMidBytes[curByteIndex++];
1543	if (resiBitsLength != 0) {
1544	unsigned char resiByte = (unsigned char) (resiBits << (8 - resiBitsLength));
1545	curBytes[reqBytesLength] = resiByte;
1546	}
1547
1548	exactData = bytesToFloat(curBytes);
1549	(*data)[index] = exactData + medianValue;
1550	memcpy(preBytes,curBytes,4);
1551	}
1552
1553	/* Process Row-i data 1 --> data r4-1 */
1554	for (jj = 1; jj < r4; jj++)
1555	{
1556	index = llr234+kkr34+ii*r4+jj;
1557
1558	pred3D = (data)[index-1] + (data)[index-r4] + (*data)[index-r34]
1559	- (data)[index-r4-1] - (data)[index-r34-r4] - (data)[index-r34-1] + (data)[index-r34-r4-1];
1560
1561
1562	type_ = type[index];
1563	if (type_ != 0)
1564	{
1565	(data)[index] = pred3D + 2 (type_ - exe_params->intvRadius) * realPrecision;
1566	}
1567	else
1568	{
1569	// compute resiBits
1570	resiBits = 0;
1571	if (resiBitsLength != 0) {
1572	int kMod8 = k % 8;
1573	int rightMovSteps = getRightMovingSteps(kMod8, resiBitsLength);
1574	if (rightMovSteps > 0) {
1575	int code = getRightMovingCode(kMod8, resiBitsLength);
1576	resiBits = (tdps->residualMidBits[p] & code) >> rightMovSteps;
1577	} else if (rightMovSteps < 0) {
1578	int code1 = getLeftMovingCode(kMod8);
1579	int code2 = getRightMovingCode(kMod8, resiBitsLength);
1580	int leftMovSteps = -rightMovSteps;
1581	rightMovSteps = 8 - leftMovSteps;
1582	resiBits = (tdps->residualMidBits[p] & code1) << leftMovSteps;
1583	p++;
1584	resiBits = resiBits
1585	\| ((tdps->residualMidBits[p] & code2) >> rightMovSteps);
1586	} else // rightMovSteps == 0
1587	{
1588	int code = getRightMovingCode(kMod8, resiBitsLength);
1589	resiBits = (tdps->residualMidBits[p] & code);
1590	p++;
1591	}
1592	k += resiBitsLength;
1593	}
1594
1595	// recover the exact data
1596	memset(curBytes, 0, 4);
1597	leadingNum = leadNum[l++];
1598	memcpy(curBytes, preBytes, leadingNum);
1599	for (j = leadingNum; j < reqBytesLength; j++)
1600	curBytes[j] = tdps->exactMidBytes[curByteIndex++];
1601	if (resiBitsLength != 0) {
1602	unsigned char resiByte = (unsigned char) (resiBits << (8 - resiBitsLength));
1603	curBytes[reqBytesLength] = resiByte;
1604	}
1605
1606	exactData = bytesToFloat(curBytes);
1607	(*data)[index] = exactData + medianValue;
1608	memcpy(preBytes,curBytes,4);
1609	}
1610	}
1611	}
1612
1613	}
1614	}
1615
1616	//I didn't implement time-based compression for 4D actually.
1617	//#ifdef HAVE_TIMECMPR
1618	// if(confparams_dec->szMode == SZ_TEMPORAL_COMPRESSION)
1619	// memcpy(multisteps->hist_data, (data), dataSeriesLengthsizeof(float));
1620	//#endif
1621
1622	free(leadNum);
1623	free(type);
1624	return;
1625	}
1626
1627	void getSnapshotData_float_1D(float** data, size_t dataSeriesLength, TightDataPointStorageF* tdps, int errBoundMode)
1628	{
1629	size_t i;
1630
1631	if (tdps->allSameData) {
1632	float value = bytesToFloat(tdps->exactMidBytes);
1633	data = (float)malloc(sizeof(float)*dataSeriesLength);
1634	for (i = 0; i < dataSeriesLength; i++)
1635	(*data)[i] = value;
1636	} else {
1637	if (tdps->rtypeArray == NULL) {
1638	if(errBoundMode < PW_REL)
1639	{
1640	#ifdef HAVE_TIMECMPR
1641	if(confparams_dec->szMode == SZ_TEMPORAL_COMPRESSION)
1642	{
1643	if(multisteps->compressionType == 0) //snapshot
1644	decompressDataSeries_float_1D(data, dataSeriesLength, tdps);
1645	else
1646	decompressDataSeries_float_1D_ts(data, dataSeriesLength, multisteps, tdps);
1647	}
1648	else
1649	#endif
1650	decompressDataSeries_float_1D(data, dataSeriesLength, tdps);
1651	}
1652	else
1653	{
1654	//decompressDataSeries_float_1D_pwr(data, dataSeriesLength, tdps);
1655	decompressDataSeries_float_1D_pwrgroup(data, dataSeriesLength, tdps);
1656	}
1657	return;
1658	} else {
1659	data = (float)malloc(sizeof(float)*dataSeriesLength);
1660	// insert the reserved values
1661	//int[] rtypes = TypeManager.convertByteArray2IntArray_fast_1b(
1662	// dataSeriesLength, rtypeArray);
1663	int* rtypes;
1664	int validLength = computeBitNumRequired(dataSeriesLength);
1665	decompressBitArraybySimpleLZ77(&rtypes, tdps->rtypeArray, tdps->rtypeArray_size, dataSeriesLength, validLength);
1666	size_t count = 0;
1667	for (i = 0; i < dataSeriesLength; i++) {
1668	if (rtypes[i] == 1)
1669	(*data)[i] = tdps->reservedValue;
1670	else
1671	count++;
1672	}
1673	// get the decompressed data
1674	float* decmpData;
1675	if(errBoundMode < PW_REL)
1676	decompressDataSeries_float_1D(&decmpData, dataSeriesLength, tdps);
1677	else
1678	decompressDataSeries_float_1D_pwr(&decmpData, dataSeriesLength, tdps);
1679	// insert the decompressed data
1680	size_t k = 0;
1681	for (i = 0; i < dataSeriesLength; i++) {
1682	if (rtypes[i] == 0) {
1683	(*data)[i] = decmpData[k++];
1684	}
1685	}
1686	free(decmpData);
1687	free(rtypes);
1688	}
1689	}
1690	}
1691
1692	void getSnapshotData_float_2D(float** data, size_t r1, size_t r2, TightDataPointStorageF* tdps, int errBoundMode)
1693	{
1694	size_t i;
1695	size_t dataSeriesLength = r1*r2;
1696	if (tdps->allSameData) {
1697	float value = bytesToFloat(tdps->exactMidBytes);
1698	data = (float)malloc(sizeof(float)*dataSeriesLength);
1699	for (i = 0; i < dataSeriesLength; i++)
1700	(*data)[i] = value;
1701	} else {
1702	if (tdps->rtypeArray == NULL) {
1703	if(errBoundMode < PW_REL)
1704	{
1705	#ifdef HAVE_TIMECMPR
1706	if(confparams_dec->szMode == SZ_TEMPORAL_COMPRESSION)
1707	{
1708	if(multisteps->compressionType == 0)
1709	decompressDataSeries_float_2D(data, r1, r2, tdps);
1710	else
1711	decompressDataSeries_float_1D_ts(data, r1*r2, multisteps, tdps);
1712	}
1713	else
1714	#endif
1715	decompressDataSeries_float_2D(data, r1, r2, tdps);
1716	}
1717	else
1718	{
1719	decompressDataSeries_float_2D_pwr(data, r1, r2, tdps);
1720	}
1721
1722	return;
1723	} else {
1724	data = (float)malloc(sizeof(float)*dataSeriesLength);
1725	// insert the reserved values
1726	//int[] rtypes = TypeManager.convertByteArray2IntArray_fast_1b(
1727	// dataSeriesLength, rtypeArray);
1728	int* rtypes;
1729	int validLength = computeBitNumRequired(dataSeriesLength);
1730	decompressBitArraybySimpleLZ77(&rtypes, tdps->rtypeArray, tdps->rtypeArray_size, dataSeriesLength, validLength);
1731	size_t count = 0;
1732	for (i = 0; i < dataSeriesLength; i++) {
1733	if (rtypes[i] == 1)
1734	(*data)[i] = tdps->reservedValue;
1735	else
1736	count++;
1737	}
1738	// get the decompressed data
1739	float* decmpData;
1740	if(errBoundMode < PW_REL)
1741	decompressDataSeries_float_2D(&decmpData, r1, r2, tdps);
1742	else
1743	decompressDataSeries_float_2D_pwr(&decmpData, r1, r2, tdps);
1744	// insert the decompressed data
1745	size_t k = 0;
1746	for (i = 0; i < dataSeriesLength; i++) {
1747	if (rtypes[i] == 0) {
1748	(*data)[i] = decmpData[k++];
1749	}
1750	}
1751	free(decmpData);
1752	free(rtypes);
1753	}
1754	}
1755	}
1756
1757	void getSnapshotData_float_3D(float** data, size_t r1, size_t r2, size_t r3, TightDataPointStorageF* tdps, int errBoundMode)
1758	{
1759	size_t i;
1760	size_t dataSeriesLength = r1r2r3;
1761	if (tdps->allSameData) {
1762	float value = bytesToFloat(tdps->exactMidBytes);
1763	data = (float)malloc(sizeof(float)*dataSeriesLength);
1764	for (i = 0; i < dataSeriesLength; i++)
1765	(*data)[i] = value;
1766	} else {
1767	if (tdps->rtypeArray == NULL) {
1768	if(errBoundMode < PW_REL)
1769	{
1770	#ifdef HAVE_TIMECMPR
1771	if(confparams_dec->szMode == SZ_TEMPORAL_COMPRESSION)
1772	{
1773	if(multisteps->compressionType == 0)
1774	decompressDataSeries_float_3D(data, r1, r2, r3, tdps);
1775	else
1776	decompressDataSeries_float_1D_ts(data, r1r2r3, multisteps, tdps);
1777	}
1778	else
1779	#endif
1780	decompressDataSeries_float_3D(data, r1, r2, r3, tdps);
1781	}
1782	else
1783	{
1784	decompressDataSeries_float_3D_pwr(data, r1, r2, r3, tdps);
1785	}
1786
1787	return;
1788	} else {
1789	data = (float)malloc(sizeof(float)*dataSeriesLength);
1790	// insert the reserved values
1791	//int[] rtypes = TypeManager.convertByteArray2IntArray_fast_1b(
1792	// dataSeriesLength, rtypeArray);
1793	int* rtypes;
1794	int validLength = computeBitNumRequired(dataSeriesLength);
1795	decompressBitArraybySimpleLZ77(&rtypes, tdps->rtypeArray, tdps->rtypeArray_size, dataSeriesLength, validLength);
1796	size_t count = 0;
1797	for (i = 0; i < dataSeriesLength; i++) {
1798	if (rtypes[i] == 1)
1799	(*data)[i] = tdps->reservedValue;
1800	else
1801	count++;
1802	}
1803	// get the decompressed data
1804	float* decmpData;
1805	if(errBoundMode < PW_REL)
1806	decompressDataSeries_float_3D(&decmpData, r1, r2, r3, tdps);
1807	else
1808	decompressDataSeries_float_3D_pwr(&decmpData, r1, r2, r3, tdps);
1809	// insert the decompressed data
1810	size_t k = 0;
1811	for (i = 0; i < dataSeriesLength; i++) {
1812	if (rtypes[i] == 0) {
1813	(*data)[i] = decmpData[k++];
1814	}
1815	}
1816	free(decmpData);
1817	free(rtypes);
1818	}
1819	}
1820	}
1821
1822	void getSnapshotData_float_4D(float** data, size_t r1, size_t r2, size_t r3, size_t r4, TightDataPointStorageF* tdps, int errBoundMode)
1823	{
1824	size_t i;
1825	size_t dataSeriesLength = r1r2r3*r4;
1826	if (tdps->allSameData) {
1827	float value = bytesToFloat(tdps->exactMidBytes);
1828	data = (float)malloc(sizeof(float)*dataSeriesLength);
1829	for (i = 0; i < dataSeriesLength; i++)
1830	(*data)[i] = value;
1831	} else {
1832	if (tdps->rtypeArray == NULL) {
1833	if(errBoundMode < PW_REL)
1834	{
1835	#ifdef HAVE_TIMECMPR
1836	if(confparams_dec->szMode == SZ_TEMPORAL_COMPRESSION)
1837	{
1838	if(multisteps->compressionType == 0)
1839	decompressDataSeries_float_4D(data, r1, r2, r3, r4, tdps);
1840	else
1841	decompressDataSeries_float_1D_ts(data, r1r2r3*r4, multisteps, tdps);
1842	}
1843	else
1844	#endif
1845	decompressDataSeries_float_4D(data, r1, r2, r3, r4, tdps);
1846	}
1847	else
1848	{
1849	decompressDataSeries_float_3D_pwr(data, r1*r2, r3, r4, tdps);
1850	//ToDO
1851	//decompressDataSeries_float_4D_pwr(data, r1, r2, r3, r4, tdps);
1852	}
1853	return;
1854	} else {
1855	data = (float)malloc(sizeof(float)*dataSeriesLength);
1856	int* rtypes;
1857	int validLength = computeBitNumRequired(dataSeriesLength);
1858	decompressBitArraybySimpleLZ77(&rtypes, tdps->rtypeArray, tdps->rtypeArray_size, dataSeriesLength, validLength);
1859	size_t count = 0;
1860	for (i = 0; i < dataSeriesLength; i++) {
1861	if (rtypes[i] == 1)
1862	(*data)[i] = tdps->reservedValue;
1863	else
1864	count++;
1865	}
1866	// get the decompressed data
1867	float* decmpData;
1868	if(errBoundMode < PW_REL)
1869	decompressDataSeries_float_4D(&decmpData, r1, r2, r3, r4, tdps);
1870	else
1871	decompressDataSeries_float_3D_pwr(&decmpData, r1*r2, r3, r4, tdps);
1872	//ToDO
1873	//decompressDataSeries_float_4D_pwr(&decompData, r1, r2, r3, r4, tdps);
1874	// insert the decompressed data
1875	size_t k = 0;
1876	for (i = 0; i < dataSeriesLength; i++) {
1877	if (rtypes[i] == 0) {
1878	(*data)[i] = decmpData[k++];
1879	}
1880	}
1881	free(decmpData);
1882	free(rtypes);
1883	}
1884	}
1885	}
1886
1887	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){
1888
1889	size_t dim0_offset = dim_1 * dim_2;
1890	size_t dim1_offset = dim_2;
1891	// printf("SZ_compress_float_3D_MDQ_RA_block real dim: %d %d %d\n", real_block_dims[0], real_block_dims[1], real_block_dims[2]);
1892	// fflush(stdout);
1893
1894	size_t unpredictable_count = 0;
1895	size_t r1, r2, r3;
1896	r1 = block_dim_0;
1897	r2 = block_dim_1;
1898	r3 = block_dim_2;
1899
1900	float * cur_data_pos = data;
1901	float * last_row_pos;
1902	float pred1D, pred2D, pred3D;
1903	size_t i, j, k;
1904	size_t r23 = r2*r3;
1905	int type_;
1906	// Process Row-0 data 0
1907	pred1D = mean;
1908	type_ = type[0];
1909	// printf("Type 0 %d, mean %.4f\n", type_, mean);
1910	if (type_ != 0){
1911	cur_data_pos[0] = pred1D + 2 * (type_ - exe_params->intvRadius) * realPrecision;
1912	}
1913	else{
1914	cur_data_pos[0] = unpredictable_data[unpredictable_count ++];
1915	}
1916
1917	/* Process Row-0 data 1*/
1918	pred1D = cur_data_pos[0];
1919	type_ = type[1];
1920	if (type_ != 0){
1921	cur_data_pos[1] = pred1D + 2 * (type_ - exe_params->intvRadius) * realPrecision;
1922	}
1923	else{
1924	cur_data_pos[1] = unpredictable_data[unpredictable_count ++];
1925	}
1926	/* Process Row-0 data 2 --> data r3-1 */
1927	for (j = 2; j < r3; j++){
1928	pred1D = 2*cur_data_pos[j-1] - cur_data_pos[j-2];
1929	type_ = type[j];
1930	if (type_ != 0){
1931	cur_data_pos[j] = pred1D + 2 * (type_ - exe_params->intvRadius) * realPrecision;
1932	}
1933	else{
1934	cur_data_pos[j] = unpredictable_data[unpredictable_count ++];
1935	}
1936	}
1937
1938	last_row_pos = cur_data_pos;
1939	cur_data_pos += dim1_offset;
1940	// printf("SZ_compress_float_3D_MDQ_RA_block row 0 done, cur_data_pos: %ld\n", cur_data_pos - block_ori_data);
1941	// fflush(stdout);
1942
1943	/* Process Row-1 --> Row-r2-1 */
1944	size_t index;
1945	for (i = 1; i < r2; i++)
1946	{
1947	/* Process row-i data 0 */
1948	index = i*r3;
1949	pred1D = last_row_pos[0];
1950	type_ = type[index];
1951	if (type_ != 0){
1952	cur_data_pos[0] = pred1D + 2 * (type_ - exe_params->intvRadius) * realPrecision;
1953	}
1954	else{
1955	cur_data_pos[0] = unpredictable_data[unpredictable_count ++];
1956	}
1957	/* Process row-i data 1 --> data r3-1*/
1958	for (j = 1; j < r3; j++)
1959	{
1960	index = i*r3+j;
1961	pred2D = cur_data_pos[j-1] + last_row_pos[j] - last_row_pos[j-1];
1962	type_ = type[index];
1963	if (type_ != 0){
1964	cur_data_pos[j] = pred2D + 2 * (type_ - exe_params->intvRadius) * realPrecision;
1965	}
1966	else{
1967	cur_data_pos[j] = unpredictable_data[unpredictable_count ++];
1968	}
1969	// printf("pred2D %.2f cur_data %.2f last_row_data %.2f %.2f, result %.2f\n", pred2D, cur_data_pos[j-1], last_row_pos[j], last_row_pos[j-1], cur_data_pos[j]);
1970	// getchar();
1971	}
1972	last_row_pos = cur_data_pos;
1973	cur_data_pos += dim1_offset;
1974	}
1975	cur_data_pos += dim0_offset - r2 * dim1_offset;
1976
1977	// printf("SZ_compress_float_3D_MDQ_RA_block layer 0 done, cur_data_pos: %ld\n", cur_data_pos - block_ori_data);
1978	// fflush(stdout);
1979	// exit(0);
1980
1981	/////////////////////////// Process layer-1 --> layer-r1-1 ///////////////////////////
1982
1983	for (k = 1; k < r1; k++)
1984	{
1985	// if(idx == 63 && idy == 63 && idz == 63){
1986	// printf("SZ_compress_float_3D_MDQ_RA_block layer %d done, cur_data_pos: %ld\n", k-1, cur_data_pos - data);
1987	// fflush(stdout);
1988	// }
1989	/* Process Row-0 data 0*/
1990	index = k*r23;
1991	pred1D = cur_data_pos[- dim0_offset];
1992	type_ = type[index];
1993	if (type_ != 0){
1994	cur_data_pos[0] = pred1D + 2 * (type_ - exe_params->intvRadius) * realPrecision;
1995	}
1996	else{
1997	cur_data_pos[0] = unpredictable_data[unpredictable_count ++];
1998	}
1999	/* Process Row-0 data 1 --> data r3-1 */
2000	for (j = 1; j < r3; j++)
2001	{
2002	//index = kr2r3+j;
2003	index ++;
2004	pred2D = cur_data_pos[j-1] + cur_data_pos[j - dim0_offset] - cur_data_pos[j - 1 - dim0_offset];
2005	type_ = type[index];
2006	if (type_ != 0){
2007	cur_data_pos[j] = pred2D + 2 * (type_ - exe_params->intvRadius) * realPrecision;
2008	}
2009	else{
2010	cur_data_pos[j] = unpredictable_data[unpredictable_count ++];
2011	}
2012	// printf("pred2D %.2f cur_data %.2f %.2f %.2f, result %.2f\n", pred2D, cur_data_pos[j-1], cur_data_pos[j - dim0_offset], cur_data_pos[j - 1 - dim0_offset], cur_data_pos[j]);
2013	// getchar();
2014	}
2015	last_row_pos = cur_data_pos;
2016	cur_data_pos += dim1_offset;
2017
2018	// if(idx == 63 && idy == 63 && idz == 63){
2019	// printf("SZ_compress_float_3D_MDQ_RA_block layer row 0 done, cur_data_pos: %ld\n", k-1, cur_data_pos - data);
2020	// fflush(stdout);
2021	// }
2022
2023	/* Process Row-1 --> Row-r2-1 */
2024	for (i = 1; i < r2; i++)
2025	{
2026	// if(idx == 63 && idy == 63 && idz == 63){
2027	// printf("SZ_compress_float_3D_MDQ_RA_block layer row %d done, cur_data_pos: %ld\n", i-1, cur_data_pos - data);
2028	// fflush(stdout);
2029	// }
2030	/* Process Row-i data 0 */
2031	index = kr23 + ir3;
2032	pred2D = last_row_pos[0] + cur_data_pos[- dim0_offset] - last_row_pos[- dim0_offset];
2033	type_ = type[index];
2034	if (type_ != 0){
2035	cur_data_pos[0] = pred2D + 2 * (type_ - exe_params->intvRadius) * realPrecision;
2036	}
2037	else{
2038	cur_data_pos[0] = unpredictable_data[unpredictable_count ++];
2039	}
2040
2041	/* Process Row-i data 1 --> data r3-1 */
2042	for (j = 1; j < r3; j++)
2043	{
2044	// if(k==63&&i==43&&j==27)
2045	// printf("i=%d\n", i);
2046	//index = kr2r3 + i*r3 + j;
2047	index ++;
2048	pred3D = cur_data_pos[j-1] + last_row_pos[j]+ cur_data_pos[j - dim0_offset] - last_row_pos[j-1] - last_row_pos[j - dim0_offset] - cur_data_pos[j-1 - dim0_offset] + last_row_pos[j-1 - dim0_offset];
2049	type_ = type[index];
2050	if (type_ != 0){
2051	cur_data_pos[j] = pred3D + 2 * (type_ - exe_params->intvRadius) * realPrecision;
2052	}
2053	else{
2054	cur_data_pos[j] = unpredictable_data[unpredictable_count ++];
2055	}
2056	}
2057	last_row_pos = cur_data_pos;
2058	cur_data_pos += dim1_offset;
2059	}
2060	cur_data_pos += dim0_offset - r2 * dim1_offset;
2061	}
2062
2063	return unpredictable_count;
2064	}
2065
2066	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){
2067
2068	size_t unpredictable_count = 0;
2069
2070	float * cur_data_pos = data;
2071	size_t type_index = 0;
2072	int type_;
2073	float last_over_thres = mean;
2074	for(size_t i=0; i<block_dim_0; i++){
2075	type_ = type[type_index];
2076	if(type_ == 0){
2077	cur_data_pos[0] = unpredictable_data[unpredictable_count ++];
2078	last_over_thres = cur_data_pos[0];
2079	}
2080	else{
2081	cur_data_pos[0] = last_over_thres + 2 * (type_ - exe_params->intvRadius) * realPrecision;
2082	last_over_thres = cur_data_pos[0];
2083	}
2084
2085	type_index ++;
2086	cur_data_pos ++;
2087	}
2088
2089	return unpredictable_count;
2090	}
2091
2092	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){
2093
2094	size_t dim0_offset = dim_1;
2095	// printf("SZ_compress_float_3D_MDQ_RA_block real dim: %d %d %d\n", real_block_dims[0], real_block_dims[1], real_block_dims[2]);
2096	// fflush(stdout);
2097
2098	size_t unpredictable_count = 0;
2099	size_t r1, r2;
2100	r1 = block_dim_0;
2101	r2 = block_dim_1;
2102
2103	float * cur_data_pos = data;
2104	float * last_row_pos;
2105	float pred1D, pred2D;
2106	size_t i, j;
2107	int type_;
2108	// Process Row-0 data 0
2109	pred1D = mean;
2110	type_ = type[0];
2111	// printf("Type 0 %d, mean %.4f\n", type_, mean);
2112	if (type_ != 0){
2113	cur_data_pos[0] = pred1D + 2 * (type_ - exe_params->intvRadius) * realPrecision;
2114	}
2115	else{
2116	cur_data_pos[0] = unpredictable_data[unpredictable_count ++];
2117	}
2118
2119	/* Process Row-0 data 1*/
2120	pred1D = cur_data_pos[0];
2121	type_ = type[1];
2122	if (type_ != 0){
2123	cur_data_pos[1] = pred1D + 2 * (type_ - exe_params->intvRadius) * realPrecision;
2124	}
2125	else{
2126	cur_data_pos[1] = unpredictable_data[unpredictable_count ++];
2127	}
2128	/* Process Row-0 data 2 --> data r3-1 */
2129	for (j = 2; j < r2; j++){
2130	pred1D = 2*cur_data_pos[j-1] - cur_data_pos[j-2];
2131	type_ = type[j];
2132	if (type_ != 0){
2133	cur_data_pos[j] = pred1D + 2 * (type_ - exe_params->intvRadius) * realPrecision;
2134	}
2135	else{
2136	cur_data_pos[j] = unpredictable_data[unpredictable_count ++];
2137	}
2138	}
2139
2140	last_row_pos = cur_data_pos;
2141	cur_data_pos += dim0_offset;
2142	// printf("SZ_compress_float_3D_MDQ_RA_block row 0 done, cur_data_pos: %ld\n", cur_data_pos - block_ori_data);
2143	// fflush(stdout);
2144
2145	/* Process Row-1 --> Row-r2-1 */
2146	size_t index;
2147	for (i = 1; i < r1; i++)
2148	{
2149	/* Process row-i data 0 */
2150	index = i*r2;
2151	type_ = type[index];
2152	if (type_ != 0){
2153	pred1D = last_row_pos[0];
2154	cur_data_pos[0] = pred1D + 2 * (type_ - exe_params->intvRadius) * realPrecision;
2155	}
2156	else{
2157	cur_data_pos[0] = unpredictable_data[unpredictable_count ++];
2158	}
2159	/* Process row-i data 1 --> data r3-1*/
2160	for (j = 1; j < r2; j++)
2161	{
2162	index = i*r2+j;
2163	pred2D = cur_data_pos[j-1] + last_row_pos[j] - last_row_pos[j-1];
2164	type_ = type[index];
2165	if (type_ != 0){
2166	cur_data_pos[j] = pred2D + 2 * (type_ - exe_params->intvRadius) * realPrecision;
2167	}
2168	else{
2169	cur_data_pos[j] = unpredictable_data[unpredictable_count ++];
2170	}
2171	// printf("pred2D %.2f cur_data %.2f last_row_data %.2f %.2f, result %.2f\n", pred2D, cur_data_pos[j-1], last_row_pos[j], last_row_pos[j-1], cur_data_pos[j]);
2172	// getchar();
2173	}
2174	last_row_pos = cur_data_pos;
2175	cur_data_pos += dim0_offset;
2176	}
2177	return unpredictable_count;
2178	}
2179

Note: See TracBrowser for help on using the repository browser.

Download in other formats: