void SZ_compress_args_float_StoreOriData(float* oriData, int dataLength, TightDataPointStorageF* tdps,
unsigned char** newByteData, int *outSize)
{
int floatSize=sizeof(float);
int k = 0, i;
tdps->isLossless = 1;
int totalByteLength = 3 + 4 + 1 + floatSize*dataLength;
*newByteData = (unsigned char*)malloc(totalByteLength);
unsigned char dsLengthBytes[4];
intToBytes_bigEndian(dsLengthBytes, dataLength);//4
for (i = 0; i < 3; i++)//3
(*newByteData)[k++] = versionNumber[i];
for (i = 0; i < 4; i++)//4
(*newByteData)[k++] = dsLengthBytes[i];
(*newByteData)[k++] = 16; //=00010000
if(sysEndianType==BIG_ENDIAN_SYSTEM)
memcpy((*newByteData)+8, oriData, dataLength*floatSize);
else
{
unsigned char* p = (*newByteData)+8;
for(i=0;i<dataLength;i++,p+=floatSize)
floatToBytes(p, oriData[i]);
}
*outSize = totalByteLength;
}
/**
* to be used in decompression and compression, inside the H5Z_filter_sz().
* */
void SZ_cdArrayToMetaData(size_t cd_nelmts, const unsigned int cd_values[], int* dimSize, int* dataType, size_t* r5, size_t* r4, size_t* r3, size_t* r2, size_t* r1)
{
//printf("cd_nelmts=%zu\n", cd_nelmts);
assert(cd_nelmts >= 4);
unsigned char bytes[8];
*dimSize = cd_values[0];
*dataType = cd_values[1];
switch(*dimSize)
{
case 1:
intToBytes_bigEndian(bytes, cd_values[2]);
intToBytes_bigEndian(&bytes[4], cd_values[3]);
if(sizeof(size_t)==4)
*r1 = (unsigned int)bytesToLong_bigEndian(bytes);
else
*r1 = (unsigned long)bytesToLong_bigEndian(bytes);
*r2 = *r3 = *r4 = *r5 = 0;
break;
case 2:
*r3 = *r4 = *r5 = 0;
*r2 = cd_values[3];
*r1 = cd_values[2];
break;
case 3:
*r4 = *r5 = 0;
*r3 = cd_values[4];
*r2 = cd_values[3];
*r1 = cd_values[2];
break;
case 4:
*r5 = 0;
*r4 = cd_values[5];
*r3 = cd_values[4];
*r2 = cd_values[3];
*r1 = cd_values[2];
break;
default:
*r5 = cd_values[6];
*r4 = cd_values[5];
*r3 = cd_values[4];
*r2 = cd_values[3];
*r1 = cd_values[2];
}
//printf("SZ_cdArrayToMetaData: r5=%zu, r4=%zu, r3=%zu, r2=%zu, r1=%zu\n", *r5, *r4, *r3, *r2, *r1);
}
void compressSingleFloatValue(FloatValueCompressElement *vce, float tgtValue, float precision, float medianValue,
int reqLength, int reqBytesLength, int resiBitsLength)
{
float normValue = tgtValue - medianValue;
lfloat lfBuf;
lfBuf.value = normValue;
int ignBytesLength = 32 - reqLength;
if(ignBytesLength<0)
ignBytesLength = 0;
int tmp_int = lfBuf.ivalue;
intToBytes_bigEndian(vce->curBytes, tmp_int);
lfBuf.ivalue = (lfBuf.ivalue >> ignBytesLength) << ignBytesLength;
//float tmpValue = lfBuf.value;
vce->data = lfBuf.value+medianValue;
vce->curValue = tmp_int;
vce->reqBytesLength = reqBytesLength;
vce->resiBitsLength = resiBitsLength;
}
void SZ_compress_args_float_NoCkRngeNoGzip_3D_pwr(unsigned char** newByteData, float *oriData, int r1, int r2, int r3,
int *outSize, float min, float max)
{
SZ_Reset();
int dataLength=r1*r2*r3;
int blockEdgeSize = computeBlockEdgeSize_3D(segment_size);
int R1 = 1+(r1-1)/blockEdgeSize;
int R2 = 1+(r2-1)/blockEdgeSize;
int R3 = 1+(r3-1)/blockEdgeSize;
//float*** pwrErrBound = create3DArray_float(R1, R2, R3);
float* pwrErrBound = (float*)malloc(sizeof(float)*R1*R2*R3);
int pwrErrBoundBytes_size = sizeof(unsigned char)*R1*R2*R3*2;
unsigned char* pwrErrBoundBytes = (unsigned char*)malloc(pwrErrBoundBytes_size);
compute_segment_precisions_float_3D(oriData, pwrErrBound, r1, r2, r3, R2, R3, blockEdgeSize, pwrErrBoundBytes, min, max);
unsigned int quantization_intervals;
if(optQuantMode==1)
{
quantization_intervals = optimize_intervals_float_3D_pwr(oriData, r1, r2, r3, R2, R3, blockEdgeSize, pwrErrBound);
updateQuantizationInfo(quantization_intervals);
}
else
quantization_intervals = intvCapacity;
//clearHuffmanMem();
int i=0,j=0,k=0, reqLength, I = 0, J = 0, K = 0;
float realPrecision = pwrErrBound[0];
float pred1D, pred2D, pred3D;
float diff = 0.0;
double itvNum = 0;
float *P0, *P1;
int r23 = r2*r3;
int R23 = R2*R3;
P0 = (float*)malloc(r23*sizeof(float));
P1 = (float*)malloc(r23*sizeof(float));
float radius = fabs(max)<fabs(min)?fabs(min):fabs(max);
float medianValue = 0;
short radExpo = getExponent_float(radius);
int updateReqLength = 0;
computeReqLength_float(realPrecision, radExpo, &reqLength, &medianValue);
int* type = (int*) malloc(dataLength*sizeof(int));
//type[dataLength]=0;
float* spaceFillingValue = oriData; //
DynamicByteArray *resiBitLengthArray;
new_DBA(&resiBitLengthArray, DynArrayInitLen);
DynamicIntArray *exactLeadNumArray;
new_DIA(&exactLeadNumArray, DynArrayInitLen);
DynamicByteArray *exactMidByteArray;
new_DBA(&exactMidByteArray, DynArrayInitLen);
DynamicIntArray *resiBitArray;
new_DIA(&resiBitArray, DynArrayInitLen);
type[0] = 0;
unsigned char preDataBytes[4];
intToBytes_bigEndian(preDataBytes, 0);
int reqBytesLength = reqLength/8;
int resiBitsLength = reqLength%8;
FloatValueCompressElement *vce = (FloatValueCompressElement*)malloc(sizeof(FloatValueCompressElement));
LossyCompressionElement *lce = (LossyCompressionElement*)malloc(sizeof(LossyCompressionElement));
/////////////////////////// Process layer-0 ///////////////////////////
/* Process Row-0 data 0*/
type[0] = 0;
addDBA_Data(resiBitLengthArray, (unsigned char)resiBitsLength);
compressSingleFloatValue(vce, spaceFillingValue[0], realPrecision, medianValue, reqLength, reqBytesLength, resiBitsLength);
updateLossyCompElement_Float(vce->curBytes, preDataBytes, reqBytesLength, resiBitsLength, lce);
memcpy(preDataBytes,vce->curBytes,4);
addExactData(exactMidByteArray, exactLeadNumArray, resiBitArray, lce);
P1[0] = vce->data;
/* Process Row-0 data 1*/
pred1D = P1[0];
diff = spaceFillingValue[1] - pred1D;
itvNum = fabs(diff)/realPrecision + 1;
if (itvNum < intvCapacity)
{
if (diff < 0) itvNum = -itvNum;
type[1] = (int) (itvNum/2) + intvRadius;
P1[1] = pred1D + 2 * (type[1] - intvRadius) * realPrecision;
}
else
{
if(updateReqLength==0)
{
computeReqLength_float(realPrecision, radExpo, &reqLength, &medianValue);
reqBytesLength = reqLength/8;
resiBitsLength = reqLength%8;
updateReqLength = 1;
}
type[1] = 0;
addDBA_Data(resiBitLengthArray, (unsigned char)resiBitsLength);
compressSingleFloatValue(vce, spaceFillingValue[1], realPrecision, medianValue, reqLength, reqBytesLength, resiBitsLength);
updateLossyCompElement_Float(vce->curBytes, preDataBytes, reqBytesLength, resiBitsLength, lce);
memcpy(preDataBytes,vce->curBytes,4);
addExactData(exactMidByteArray, exactLeadNumArray, resiBitArray, lce);
P1[1] = vce->data;
}
/* Process Row-0 data 2 --> data r3-1 */
for (j = 2; j < r3; j++)
{
if(j%blockEdgeSize==0)
{
J++;
realPrecision = pwrErrBound[J];
updateReqLength = 0;
}
pred1D = 2*P1[j-1] - P1[j-2];
diff = spaceFillingValue[j] - pred1D;
itvNum = fabs(diff)/realPrecision + 1;
if (itvNum < intvCapacity)
{
if (diff < 0) itvNum = -itvNum;
type[j] = (int) (itvNum/2) + intvRadius;
P1[j] = pred1D + 2 * (type[j] - intvRadius) * realPrecision;
}
else
{
if(updateReqLength==0)
{
computeReqLength_float(realPrecision, radExpo, &reqLength, &medianValue);
reqBytesLength = reqLength/8;
resiBitsLength = reqLength%8;
updateReqLength = 1;
}
type[j] = 0;
addDBA_Data(resiBitLengthArray, (unsigned char)resiBitsLength);
compressSingleFloatValue(vce, spaceFillingValue[j], realPrecision, medianValue, reqLength, reqBytesLength, resiBitsLength);
updateLossyCompElement_Float(vce->curBytes, preDataBytes, reqBytesLength, resiBitsLength, lce);
memcpy(preDataBytes,vce->curBytes,4);
addExactData(exactMidByteArray, exactLeadNumArray, resiBitArray, lce);
P1[j] = vce->data;
}
}
/* Process Row-1 --> Row-r2-1 */
int index;
K = 0;
for (i = 1; i < r2; i++)
{
/* Process row-i data 0 */
index = i*r3;
J = 0;
if(i%blockEdgeSize==0)
I++;
realPrecision = pwrErrBound[I*R3+J]; //J==0
updateReqLength = 0;
pred1D = P1[index-r3];
diff = spaceFillingValue[index] - pred1D;
itvNum = fabs(diff)/realPrecision + 1;
if (itvNum < intvCapacity)
{
if (diff < 0) itvNum = -itvNum;
type[index] = (int) (itvNum/2) + intvRadius;
P1[index] = pred1D + 2 * (type[index] - intvRadius) * realPrecision;
}
else
{
if(updateReqLength==0)
{
computeReqLength_float(realPrecision, radExpo, &reqLength, &medianValue);
reqBytesLength = reqLength/8;
resiBitsLength = reqLength%8;
updateReqLength = 1;
}
type[index] = 0;
addDBA_Data(resiBitLengthArray, (unsigned char)resiBitsLength);
compressSingleFloatValue(vce, spaceFillingValue[index], realPrecision, medianValue, reqLength, reqBytesLength, resiBitsLength);
updateLossyCompElement_Float(vce->curBytes, preDataBytes, reqBytesLength, resiBitsLength, lce);
memcpy(preDataBytes,vce->curBytes,4);
addExactData(exactMidByteArray, exactLeadNumArray, resiBitArray, lce);
P1[index] = vce->data;
}
/* Process row-i data 1 --> data r3-1*/
for (j = 1; j < r3; j++) //note that this j refers to fastest dimension (lowest order)
{
index = i*r3+j;
if(j%blockEdgeSize==0)
{
J++;
realPrecision = pwrErrBound[I*R3+J];
updateReqLength = 0;
}
pred2D = P1[index-1] + P1[index-r3] - P1[index-r3-1];
diff = spaceFillingValue[index] - pred2D;
itvNum = fabs(diff)/realPrecision + 1;
if (itvNum < intvCapacity)
{
if (diff < 0) itvNum = -itvNum;
type[index] = (int) (itvNum/2) + intvRadius;
P1[index] = pred2D + 2 * (type[index] - intvRadius) * realPrecision;
}
else
{
if(updateReqLength==0)
{
computeReqLength_float(realPrecision, radExpo, &reqLength, &medianValue);
reqBytesLength = reqLength/8;
resiBitsLength = reqLength%8;
updateReqLength = 1;
}
type[index] = 0;
addDBA_Data(resiBitLengthArray, (unsigned char)resiBitsLength);
compressSingleFloatValue(vce, spaceFillingValue[index], realPrecision, medianValue, reqLength, reqBytesLength, resiBitsLength);
updateLossyCompElement_Float(vce->curBytes, preDataBytes, reqBytesLength, resiBitsLength, lce);
memcpy(preDataBytes,vce->curBytes,4);
addExactData(exactMidByteArray, exactLeadNumArray, resiBitArray, lce);
P1[index] = vce->data;
}
}
}
/////////////////////////// Process layer-1 --> layer-r1-1 ///////////////////////////
for (k = 1; k < r1; k++)
{
/* Process Row-0 data 0*/
index = k*r23;
I = 0;
J = 0;
if(k%blockEdgeSize==0)
K++;
realPrecision = pwrErrBound[K*R23]; //J==0
updateReqLength = 0;
pred1D = P1[0];
diff = spaceFillingValue[index] - pred1D;
itvNum = fabs(diff)/realPrecision + 1;
if (itvNum < intvCapacity)
{
if (diff < 0) itvNum = -itvNum;
type[index] = (int) (itvNum/2) + intvRadius;
P0[0] = pred1D + 2 * (type[index] - intvRadius) * realPrecision;
}
else
{
if(updateReqLength==0)
{
computeReqLength_float(realPrecision, radExpo, &reqLength, &medianValue);
reqBytesLength = reqLength/8;
resiBitsLength = reqLength%8;
updateReqLength = 1;
}
type[index] = 0;
addDBA_Data(resiBitLengthArray, (unsigned char)resiBitsLength);
compressSingleFloatValue(vce, spaceFillingValue[index], realPrecision, medianValue, reqLength, reqBytesLength, resiBitsLength);
updateLossyCompElement_Float(vce->curBytes, preDataBytes, reqBytesLength, resiBitsLength, lce);
memcpy(preDataBytes,vce->curBytes,4);
addExactData(exactMidByteArray, exactLeadNumArray, resiBitArray, lce);
P0[0] = vce->data;
}
/* Process Row-0 data 1 --> data r3-1 */
for (j = 1; j < r3; j++)
{
index = k*r23+j;
if(j%blockEdgeSize==0)
{
J++;
realPrecision = pwrErrBound[K*R23+J];
updateReqLength = 0;
}
pred2D = P0[j-1] + P1[j] - P1[j-1];
diff = spaceFillingValue[index] - pred2D;
itvNum = fabs(diff)/realPrecision + 1;
if (itvNum < intvCapacity)
{
if (diff < 0) itvNum = -itvNum;
type[index] = (int) (itvNum/2) + intvRadius;
P0[j] = pred2D + 2 * (type[index] - intvRadius) * realPrecision;
/* if(type[index]==0)
printf("err:type[%d]=0, index4\n", index); */
}
else
{
if(updateReqLength==0)
{
computeReqLength_float(realPrecision, radExpo, &reqLength, &medianValue);
reqBytesLength = reqLength/8;
resiBitsLength = reqLength%8;
updateReqLength = 1;
}
type[index] = 0;
addDBA_Data(resiBitLengthArray, (unsigned char)resiBitsLength);
compressSingleFloatValue(vce, spaceFillingValue[index], realPrecision, medianValue, reqLength, reqBytesLength, resiBitsLength);
updateLossyCompElement_Float(vce->curBytes, preDataBytes, reqBytesLength, resiBitsLength, lce);
memcpy(preDataBytes,vce->curBytes,4);
addExactData(exactMidByteArray, exactLeadNumArray, resiBitArray, lce);
P0[j] = vce->data;
}
}
/* Process Row-1 --> Row-r2-1 */
int index2D;
for (i = 1; i < r2; i++)
{
/* Process Row-i data 0 */
index = k*r23 + i*r3;
J = 0;
if(i%blockEdgeSize==0)
I++;
realPrecision = pwrErrBound[K*R23+I*R3+J]; //J==0
updateReqLength = 0;
index2D = i*r3;
pred2D = P0[index2D-r3] + P1[index2D] - P1[index2D-r3];
diff = spaceFillingValue[index] - pred2D;
itvNum = fabs(diff)/realPrecision + 1;
if (itvNum < intvCapacity)
{
if (diff < 0) itvNum = -itvNum;
type[index] = (int) (itvNum/2) + intvRadius;
P0[index2D] = pred2D + 2 * (type[index] - intvRadius) * realPrecision;
}
else
{
if(updateReqLength==0)
{
computeReqLength_float(realPrecision, radExpo, &reqLength, &medianValue);
reqBytesLength = reqLength/8;
resiBitsLength = reqLength%8;
updateReqLength = 1;
}
type[index] = 0;
addDBA_Data(resiBitLengthArray, (unsigned char)resiBitsLength);
compressSingleFloatValue(vce, spaceFillingValue[index], realPrecision, medianValue, reqLength, reqBytesLength, resiBitsLength);
updateLossyCompElement_Float(vce->curBytes, preDataBytes, reqBytesLength, resiBitsLength, lce);
memcpy(preDataBytes,vce->curBytes,4);
addExactData(exactMidByteArray, exactLeadNumArray, resiBitArray, lce);
P0[index2D] = vce->data;
}
/* Process Row-i data 1 --> data r3-1 */
for (j = 1; j < r3; j++)
{
index = k*r23 + i*r3 + j;
if(j%blockEdgeSize==0)
{
J++;
realPrecision = pwrErrBound[K*R23+I*R3+J];
updateReqLength = 0;
}
index2D = i*r3 + j;
pred3D = P0[index2D-1] + P0[index2D-r3]+ P1[index2D] - P0[index2D-r3-1] - P1[index2D-r3] - P1[index2D-1] + P1[index2D-r3-1];
diff = spaceFillingValue[index] - pred3D;
itvNum = fabs(diff)/realPrecision + 1;
if (itvNum < intvCapacity)
{
if (diff < 0) itvNum = -itvNum;
type[index] = (int) (itvNum/2) + intvRadius;
P0[index2D] = pred3D + 2 * (type[index] - intvRadius) * realPrecision;
}
else
{
if(updateReqLength==0)
{
computeReqLength_float(realPrecision, radExpo, &reqLength, &medianValue);
reqBytesLength = reqLength/8;
resiBitsLength = reqLength%8;
updateReqLength = 1;
}
type[index] = 0;
addDBA_Data(resiBitLengthArray, (unsigned char)resiBitsLength);
compressSingleFloatValue(vce, spaceFillingValue[index], realPrecision, medianValue, reqLength, reqBytesLength, resiBitsLength);
updateLossyCompElement_Float(vce->curBytes, preDataBytes, reqBytesLength, resiBitsLength, lce);
memcpy(preDataBytes,vce->curBytes,4);
addExactData(exactMidByteArray, exactLeadNumArray, resiBitArray, lce);
P0[index2D] = vce->data;
}
}
}
float *Pt;
Pt = P1;
P1 = P0;
P0 = Pt;
}
if(r23!=1)
free(P0);
free(P1);
int exactDataNum = exactLeadNumArray->size;
TightDataPointStorageF* tdps;
new_TightDataPointStorageF(&tdps, dataLength, exactDataNum,
type, exactMidByteArray->array, exactMidByteArray->size,
exactLeadNumArray->array,
resiBitArray->array, resiBitArray->size,
resiBitLengthArray->array, resiBitLengthArray->size,
realPrecision, medianValue, (char)reqLength, quantization_intervals, pwrErrBoundBytes, pwrErrBoundBytes_size, radExpo);
//sdi:Debug
/* int sum =0;
for(i=0;i<dataLength;i++)
if(type[i]==0) sum++;
printf("opt_quantizations=%d, exactDataNum=%d, sum=%d\n",quantization_intervals, exactDataNum, sum);
*/
//free memory
free_DBA(resiBitLengthArray);
free_DIA(exactLeadNumArray);
free_DIA(resiBitArray);
free(type);
convertTDPStoFlatBytes_float(tdps, newByteData, outSize);
free(pwrErrBound);
free(vce);
free(lce);
free_TightDataPointStorageF(tdps);
free(exactMidByteArray);
}
void SZ_compress_args_float_NoCkRngeNoGzip_2D_pwr(unsigned char** newByteData, float *oriData, int r1, int r2,
int *outSize, float min, float max)
{
SZ_Reset();
int dataLength=r1*r2;
int blockEdgeSize = computeBlockEdgeSize_2D(segment_size);
int R1 = 1+(r1-1)/blockEdgeSize;
int R2 = 1+(r2-1)/blockEdgeSize;
float* pwrErrBound = (float*)malloc(sizeof(float)*R1*R2);
int pwrErrBoundBytes_size = sizeof(unsigned char)*R1*R2*2;
unsigned char* pwrErrBoundBytes = (unsigned char*)malloc(pwrErrBoundBytes_size);
compute_segment_precisions_float_2D(oriData, pwrErrBound, r1, r2, R2, blockEdgeSize, pwrErrBoundBytes, min, max);
unsigned int quantization_intervals;
if(optQuantMode==1)
{
quantization_intervals = optimize_intervals_float_2D_pwr(oriData, r1, r2, R2, blockEdgeSize, pwrErrBound);
updateQuantizationInfo(quantization_intervals);
}
else
quantization_intervals = intvCapacity;
//clearHuffmanMem();
//printf("quantization_intervals=%d\n",quantization_intervals);
int i=0,j=0,I=0,J=0,reqLength;
float realPrecision = pwrErrBound[I*R2+J];
float pred1D, pred2D;
float diff = 0.0;
double itvNum = 0;
float *P0, *P1;
P0 = (float*)malloc(r2*sizeof(float));
memset(P0, 0, r2*sizeof(float));
P1 = (float*)malloc(r2*sizeof(float));
memset(P1, 0, r2*sizeof(float));
float medianValue = 0;
float radius = fabs(max)<fabs(min)?fabs(min):fabs(max);
short radExpo = getExponent_float(radius);
int updateReqLength = 1;
computeReqLength_float(realPrecision, radExpo, &reqLength, &medianValue);
int* type = (int*) malloc(dataLength*sizeof(int));
//type[dataLength]=0;
float* spaceFillingValue = oriData; //
DynamicByteArray *resiBitLengthArray;
new_DBA(&resiBitLengthArray, DynArrayInitLen);
DynamicIntArray *exactLeadNumArray;
new_DIA(&exactLeadNumArray, DynArrayInitLen);
DynamicByteArray *exactMidByteArray;
new_DBA(&exactMidByteArray, DynArrayInitLen);
DynamicIntArray *resiBitArray;
new_DIA(&resiBitArray, DynArrayInitLen);
type[0] = 0;
unsigned char preDataBytes[4];
intToBytes_bigEndian(preDataBytes, 0);
int reqBytesLength = reqLength/8;
int resiBitsLength = reqLength%8;
FloatValueCompressElement *vce = (FloatValueCompressElement*)malloc(sizeof(FloatValueCompressElement));
LossyCompressionElement *lce = (LossyCompressionElement*)malloc(sizeof(LossyCompressionElement));
/* Process Row-0 data 0*/
type[0] = 0;
addDBA_Data(resiBitLengthArray, (unsigned char)resiBitsLength);
compressSingleFloatValue(vce, spaceFillingValue[0], realPrecision, medianValue, reqLength, reqBytesLength, resiBitsLength);
updateLossyCompElement_Float(vce->curBytes, preDataBytes, reqBytesLength, resiBitsLength, lce);
memcpy(preDataBytes,vce->curBytes,4);
addExactData(exactMidByteArray, exactLeadNumArray, resiBitArray, lce);
P1[0] = vce->data;
/* Process Row-0 data 1*/
pred1D = P1[0];
diff = spaceFillingValue[1] - pred1D;
itvNum = fabs(diff)/realPrecision + 1;
if (itvNum < intvCapacity)
{
if (diff < 0) itvNum = -itvNum;
type[1] = (int) (itvNum/2) + intvRadius;
P1[1] = pred1D + 2 * (type[1] - intvRadius) * realPrecision;
}
else
{
type[1] = 0;
addDBA_Data(resiBitLengthArray, (unsigned char)resiBitsLength);
compressSingleFloatValue(vce, spaceFillingValue[1], realPrecision, medianValue, reqLength, reqBytesLength, resiBitsLength);
updateLossyCompElement_Float(vce->curBytes, preDataBytes, reqBytesLength, resiBitsLength, lce);
memcpy(preDataBytes,vce->curBytes,4);
addExactData(exactMidByteArray, exactLeadNumArray, resiBitArray, lce);
P1[1] = vce->data;
}
/* Process Row-0 data 2 --> data r2-1 */
for (j = 2; j < r2; j++)
{
if(j%blockEdgeSize==0)
{
J++;
realPrecision = pwrErrBound[I*R2+J];
updateReqLength = 0;
}
pred1D = 2*P1[j-1] - P1[j-2];
diff = spaceFillingValue[j] - pred1D;
itvNum = fabs(diff)/realPrecision + 1;
if (itvNum < intvCapacity)
{
if (diff < 0) itvNum = -itvNum;
type[j] = (int) (itvNum/2) + intvRadius;
P1[j] = pred1D + 2 * (type[j] - intvRadius) * realPrecision;
}
else
{
if(updateReqLength==0)
{
computeReqLength_float(realPrecision, radExpo, &reqLength, &medianValue);
reqBytesLength = reqLength/8;
resiBitsLength = reqLength%8;
updateReqLength = 1;
}
type[j] = 0;
addDBA_Data(resiBitLengthArray, (unsigned char)resiBitsLength);
compressSingleFloatValue(vce, spaceFillingValue[j], realPrecision, medianValue, reqLength, reqBytesLength, resiBitsLength);
updateLossyCompElement_Float(vce->curBytes, preDataBytes, reqBytesLength, resiBitsLength, lce);
memcpy(preDataBytes,vce->curBytes,4);
addExactData(exactMidByteArray, exactLeadNumArray, resiBitArray, lce);
P1[j] = vce->data;
}
}
/* Process Row-1 --> Row-r1-1 */
int index;
for (i = 1; i < r1; i++)
{
/* Process row-i data 0 */
index = i*r2;
J = 0;
if(i%blockEdgeSize==0)
I++;
realPrecision = pwrErrBound[I*R2+J]; //J==0
updateReqLength = 0;
pred1D = P1[0];
diff = spaceFillingValue[index] - pred1D;
itvNum = fabs(diff)/realPrecision + 1;
if (itvNum < intvCapacity)
{
if (diff < 0) itvNum = -itvNum;
type[index] = (int) (itvNum/2) + intvRadius;
P0[0] = pred1D + 2 * (type[index] - intvRadius) * realPrecision;
}
else
{
if(updateReqLength==0)
{
computeReqLength_float(realPrecision, radExpo, &reqLength, &medianValue);
reqBytesLength = reqLength/8;
resiBitsLength = reqLength%8;
updateReqLength = 1;
}
type[index] = 0;
addDBA_Data(resiBitLengthArray, (unsigned char)resiBitsLength);
compressSingleFloatValue(vce, spaceFillingValue[index], realPrecision, medianValue, reqLength, reqBytesLength, resiBitsLength);
updateLossyCompElement_Float(vce->curBytes, preDataBytes, reqBytesLength, resiBitsLength, lce);
memcpy(preDataBytes,vce->curBytes,4);
addExactData(exactMidByteArray, exactLeadNumArray, resiBitArray, lce);
P0[0] = vce->data;
}
/* Process row-i data 1 --> r2-1*/
for (j = 1; j < r2; j++)
{
index = i*r2+j;
if(j%blockEdgeSize==0)
{
J++;
realPrecision = pwrErrBound[I*R2+J];
updateReqLength = 0;
}
pred2D = P0[j-1] + P1[j] - P1[j-1];
diff = spaceFillingValue[index] - pred2D;
itvNum = fabs(diff)/realPrecision + 1;
if (itvNum < intvCapacity)
{
if (diff < 0) itvNum = -itvNum;
type[index] = (int) (itvNum/2) + intvRadius;
P0[j] = pred2D + 2 * (type[index] - intvRadius) * realPrecision;
}
else
{
if(updateReqLength==0)
{
computeReqLength_float(realPrecision, radExpo, &reqLength, &medianValue);
reqBytesLength = reqLength/8;
resiBitsLength = reqLength%8;
updateReqLength = 1;
}
type[index] = 0;
addDBA_Data(resiBitLengthArray, (unsigned char)resiBitsLength);
compressSingleFloatValue(vce, spaceFillingValue[index], realPrecision, medianValue, reqLength, reqBytesLength, resiBitsLength);
updateLossyCompElement_Float(vce->curBytes, preDataBytes, reqBytesLength, resiBitsLength, lce);
memcpy(preDataBytes,vce->curBytes,4);
addExactData(exactMidByteArray, exactLeadNumArray, resiBitArray, lce);
P0[j] = vce->data;
}
}
float *Pt;
Pt = P1;
P1 = P0;
P0 = Pt;
}
if(r2!=1)
free(P0);
free(P1);
int exactDataNum = exactLeadNumArray->size;
TightDataPointStorageF* tdps;
new_TightDataPointStorageF(&tdps, dataLength, exactDataNum,
type, exactMidByteArray->array, exactMidByteArray->size,
exactLeadNumArray->array,
resiBitArray->array, resiBitArray->size,
resiBitLengthArray->array, resiBitLengthArray->size,
realPrecision, medianValue, (char)reqLength, quantization_intervals, pwrErrBoundBytes, pwrErrBoundBytes_size, radExpo);
//free memory
free_DBA(resiBitLengthArray);
free_DIA(exactLeadNumArray);
free_DIA(resiBitArray);
free(type);
convertTDPStoFlatBytes_float(tdps, newByteData, outSize);
free(pwrErrBound);
free(vce);
free(lce);
free_TightDataPointStorageF(tdps);
free(exactMidByteArray);
}
void SZ_compress_args_float_NoCkRngeNoGzip_1D_pwr(unsigned char** newByteData, float *oriData,
int dataLength, int *outSize, float min, float max)
{
SZ_Reset();
int pwrLength = dataLength%segment_size==0?dataLength/segment_size:dataLength/segment_size+1;
float* pwrErrBound = (float*)malloc(sizeof(float)*pwrLength);
int pwrErrBoundBytes_size = sizeof(unsigned char)*pwrLength*2;
unsigned char* pwrErrBoundBytes = (unsigned char*)malloc(pwrErrBoundBytes_size);
compute_segment_precisions_float_1D(oriData, dataLength, pwrErrBound, pwrErrBoundBytes);
unsigned int quantization_intervals;
if(optQuantMode==1)
{
quantization_intervals = optimize_intervals_float_1D_pwr(oriData, dataLength, pwrErrBound);
updateQuantizationInfo(quantization_intervals);
}
else
quantization_intervals = intvCapacity;
//clearHuffmanMem();
int i = 0, j = 0, reqLength;
float realPrecision = pwrErrBound[j++];
float medianValue = 0;
float radius = fabs(max)<fabs(min)?fabs(min):fabs(max);
short radExpo = getExponent_float(radius);
computeReqLength_float(realPrecision, radExpo, &reqLength, &medianValue);
int* type = (int*) malloc(dataLength*sizeof(int));
//type[dataLength]=0;
float* spaceFillingValue = oriData; //
DynamicByteArray *resiBitLengthArray;
new_DBA(&resiBitLengthArray, DynArrayInitLen);
DynamicIntArray *exactLeadNumArray;
new_DIA(&exactLeadNumArray, DynArrayInitLen);
DynamicByteArray *exactMidByteArray;
new_DBA(&exactMidByteArray, DynArrayInitLen);
DynamicIntArray *resiBitArray;
new_DIA(&resiBitArray, DynArrayInitLen);
type[0] = 0;
unsigned char preDataBytes[4] = {0};
intToBytes_bigEndian(preDataBytes, 0);
int reqBytesLength = reqLength/8;
int resiBitsLength = reqLength%8;
float last3CmprsData[3] = {0};
FloatValueCompressElement *vce = (FloatValueCompressElement*)malloc(sizeof(FloatValueCompressElement));
LossyCompressionElement *lce = (LossyCompressionElement*)malloc(sizeof(LossyCompressionElement));
//add the first data
addDBA_Data(resiBitLengthArray, (unsigned char)resiBitsLength);
compressSingleFloatValue(vce, spaceFillingValue[0], realPrecision, medianValue, reqLength, reqBytesLength, resiBitsLength);
updateLossyCompElement_Float(vce->curBytes, preDataBytes, reqBytesLength, resiBitsLength, lce);
memcpy(preDataBytes,vce->curBytes,4);
addExactData(exactMidByteArray, exactLeadNumArray, resiBitArray, lce);
listAdd_float(last3CmprsData, vce->data);
//printf("%.30G\n",last3CmprsData[0]);
//add the second data
type[1] = 0;
addDBA_Data(resiBitLengthArray, (unsigned char)resiBitsLength);
compressSingleFloatValue(vce, spaceFillingValue[1], realPrecision, medianValue, reqLength, reqBytesLength, resiBitsLength);
updateLossyCompElement_Float(vce->curBytes, preDataBytes, reqBytesLength, resiBitsLength, lce);
memcpy(preDataBytes,vce->curBytes,4);
addExactData(exactMidByteArray, exactLeadNumArray, resiBitArray, lce);
listAdd_float(last3CmprsData, vce->data);
//printf("%.30G\n",last3CmprsData[0]);
int state;
float lcf, qcf;
double checkRadius;
float curData;
float pred;
double predAbsErr;
float min_pred, minErr, minIndex;
int a = 0;
checkRadius = (intvCapacity-1)*realPrecision;
double interval = 2*realPrecision;
int updateReqLength = 0; //a marker: 1 means already updated
for(i=2;i<dataLength;i++)
{
// if(i==2499435)
// printf("i=%d\n", i);
curData = spaceFillingValue[i];
if(i%segment_size==0)
{
realPrecision = pwrErrBound[j++];
checkRadius = (intvCapacity-1)*realPrecision;
interval = 2*realPrecision;
updateReqLength = 0;
}
pred = 2*last3CmprsData[0] - last3CmprsData[1];
//pred = last3CmprsData[0];
predAbsErr = fabs(curData - pred);
if(predAbsErr<checkRadius)
{
state = (predAbsErr/realPrecision+1)/2;
if(curData>=pred)
{
type[i] = intvRadius+state;
pred = pred + state*interval;
}
else //curData<pred
{
type[i] = intvRadius-state;
pred = pred - state*interval;
}
/* if(type[i]==0)
printf("err:type[%d]=0\n", i);*/
listAdd_float(last3CmprsData, pred);
continue;
}
//unpredictable data processing
if(updateReqLength==0)
{
computeReqLength_float(realPrecision, radExpo, &reqLength, &medianValue);
reqBytesLength = reqLength/8;
resiBitsLength = reqLength%8;
updateReqLength = 1;
}
type[i] = 0;
addDBA_Data(resiBitLengthArray, (unsigned char)resiBitsLength);
compressSingleFloatValue(vce, curData, realPrecision, medianValue, reqLength, reqBytesLength, resiBitsLength);
updateLossyCompElement_Float(vce->curBytes, preDataBytes, reqBytesLength, resiBitsLength, lce);
memcpy(preDataBytes,vce->curBytes,4);
addExactData(exactMidByteArray, exactLeadNumArray, resiBitArray, lce);
listAdd_float(last3CmprsData, vce->data);
}//end of for
// char* expSegmentsInBytes;
// int expSegmentsInBytes_size = convertESCToBytes(esc, &expSegmentsInBytes);
int exactDataNum = exactLeadNumArray->size;
TightDataPointStorageF* tdps;
new_TightDataPointStorageF(&tdps, dataLength, exactDataNum,
type, exactMidByteArray->array, exactMidByteArray->size,
exactLeadNumArray->array,
resiBitArray->array, resiBitArray->size,
resiBitLengthArray->array, resiBitLengthArray->size,
realPrecision, medianValue, (char)reqLength, quantization_intervals, pwrErrBoundBytes, pwrErrBoundBytes_size, radExpo);
//sdi:Debug
/* int sum =0;
for(i=0;i<dataLength;i++)
if(type[i]==0) sum++;
printf("opt_quantizations=%d, exactDataNum=%d, sum=%d\n",quantization_intervals, exactDataNum, sum);
*/
// writeShortData(type, dataLength, "compressStateBytes.sb");
// unsigned short type_[dataLength];
// SZ_Reset();
// decode_withTree(tdps->typeArray, tdps->typeArray_size, type_);
// printf("tdps->typeArray_size=%d\n", tdps->typeArray_size);
//free memory
free_DBA(resiBitLengthArray);
free_DIA(exactLeadNumArray);
free_DIA(resiBitArray);
free(type);
convertTDPStoFlatBytes_float(tdps, newByteData, outSize);
int floatSize=sizeof(float);
if(*outSize>dataLength*floatSize)
{
int k = 0, i;
tdps->isLossless = 1;
int totalByteLength = 3 + 4 + 1 + floatSize*dataLength;
*newByteData = (unsigned char*)malloc(totalByteLength);
unsigned char dsLengthBytes[4];
intToBytes_bigEndian(dsLengthBytes, dataLength);//4
for (i = 0; i < 3; i++)//3
(*newByteData)[k++] = versionNumber[i];
for (i = 0; i < 4; i++)//4
(*newByteData)[k++] = dsLengthBytes[i];
(*newByteData)[k++] = 16; //=00010000
if(sysEndianType==BIG_ENDIAN_SYSTEM)
memcpy((*newByteData)+8, oriData, dataLength*floatSize);
else
{
unsigned char* p = (*newByteData)+8;
for(i=0;i<dataLength;i++,p+=floatSize)
floatToBytes(p, oriData[i]);
}
*outSize = totalByteLength;
}
free(pwrErrBound);
free(vce);
free(lce);
free_TightDataPointStorageF(tdps);
free(exactMidByteArray);
}
TightDataPointStorageF* SZ_compress_float_3D_MDQ(float *oriData, int r1, int r2, int r3, double realPrecision, float valueRangeSize, float medianValue_f)
{
unsigned int quantization_intervals;
if(optQuantMode==1)
{
quantization_intervals = optimize_intervals_float_3D(oriData, r1, r2, r3, realPrecision);
updateQuantizationInfo(quantization_intervals);
}
else
quantization_intervals = intvCapacity;
//clearHuffmanMem();
int i,j,k, reqLength;
float pred1D, pred2D, pred3D;
float diff = 0.0;
double itvNum = 0;
float *P0, *P1;
int dataLength = r1*r2*r3;
int r23 = r2*r3;
P0 = (float*)malloc(r23*sizeof(float));
P1 = (float*)malloc(r23*sizeof(float));
float medianValue = medianValue_f;
short radExpo = getExponent_float(valueRangeSize/2);
computeReqLength_float(realPrecision, radExpo, &reqLength, &medianValue);
int* type = (int*) malloc(dataLength*sizeof(int));
//type[dataLength]=0;
float* spaceFillingValue = oriData; //
DynamicByteArray *resiBitLengthArray;
new_DBA(&resiBitLengthArray, DynArrayInitLen);
DynamicIntArray *exactLeadNumArray;
new_DIA(&exactLeadNumArray, DynArrayInitLen);
DynamicByteArray *exactMidByteArray;
new_DBA(&exactMidByteArray, DynArrayInitLen);
DynamicIntArray *resiBitArray;
new_DIA(&resiBitArray, DynArrayInitLen);
type[0] = 0;
unsigned char preDataBytes[4];
intToBytes_bigEndian(preDataBytes, 0);
int reqBytesLength = reqLength/8;
int resiBitsLength = reqLength%8;
FloatValueCompressElement *vce = (FloatValueCompressElement*)malloc(sizeof(FloatValueCompressElement));
LossyCompressionElement *lce = (LossyCompressionElement*)malloc(sizeof(LossyCompressionElement));
/////////////////////////// Process layer-0 ///////////////////////////
/* Process Row-0 data 0*/
type[0] = 0;
addDBA_Data(resiBitLengthArray, (unsigned char)resiBitsLength);
compressSingleFloatValue(vce, spaceFillingValue[0], realPrecision, medianValue, reqLength, reqBytesLength, resiBitsLength);
updateLossyCompElement_Float(vce->curBytes, preDataBytes, reqBytesLength, resiBitsLength, lce);
memcpy(preDataBytes,vce->curBytes,4);
addExactData(exactMidByteArray, exactLeadNumArray, resiBitArray, lce);
P1[0] = vce->data;
/* Process Row-0 data 1*/
pred1D = P1[0];
diff = spaceFillingValue[1] - pred1D;
itvNum = fabs(diff)/realPrecision + 1;
if (itvNum < intvCapacity)
{
if (diff < 0) itvNum = -itvNum;
type[1] = (int) (itvNum/2) + intvRadius;
P1[1] = pred1D + 2 * (type[1] - intvRadius) * realPrecision;
}
else
{
type[1] = 0;
addDBA_Data(resiBitLengthArray, (unsigned char)resiBitsLength);
compressSingleFloatValue(vce, spaceFillingValue[1], realPrecision, medianValue, reqLength, reqBytesLength, resiBitsLength);
updateLossyCompElement_Float(vce->curBytes, preDataBytes, reqBytesLength, resiBitsLength, lce);
memcpy(preDataBytes,vce->curBytes,4);
addExactData(exactMidByteArray, exactLeadNumArray, resiBitArray, lce);
P1[1] = vce->data;
}
/* Process Row-0 data 2 --> data r3-1 */
for (j = 2; j < r3; j++)
{
pred1D = 2*P1[j-1] - P1[j-2];
diff = spaceFillingValue[j] - pred1D;
itvNum = fabs(diff)/realPrecision + 1;
if (itvNum < intvCapacity)
{
if (diff < 0) itvNum = -itvNum;
type[j] = (int) (itvNum/2) + intvRadius;
P1[j] = pred1D + 2 * (type[j] - intvRadius) * realPrecision;
}
else
{
type[j] = 0;
addDBA_Data(resiBitLengthArray, (unsigned char)resiBitsLength);
compressSingleFloatValue(vce, spaceFillingValue[j], realPrecision, medianValue, reqLength, reqBytesLength, resiBitsLength);
updateLossyCompElement_Float(vce->curBytes, preDataBytes, reqBytesLength, resiBitsLength, lce);
memcpy(preDataBytes,vce->curBytes,4);
addExactData(exactMidByteArray, exactLeadNumArray, resiBitArray, lce);
P1[j] = vce->data;
}
}
/* Process Row-1 --> Row-r2-1 */
int index;
for (i = 1; i < r2; i++)
{
/* Process row-i data 0 */
index = i*r3;
pred1D = P1[index-r3];
diff = spaceFillingValue[index] - pred1D;
itvNum = fabs(diff)/realPrecision + 1;
if (itvNum < intvCapacity)
{
if (diff < 0) itvNum = -itvNum;
type[index] = (int) (itvNum/2) + intvRadius;
P1[index] = pred1D + 2 * (type[index] - intvRadius) * realPrecision;
}
else
{
type[index] = 0;
addDBA_Data(resiBitLengthArray, (unsigned char)resiBitsLength);
compressSingleFloatValue(vce, spaceFillingValue[index], realPrecision, medianValue, reqLength, reqBytesLength, resiBitsLength);
updateLossyCompElement_Float(vce->curBytes, preDataBytes, reqBytesLength, resiBitsLength, lce);
memcpy(preDataBytes,vce->curBytes,4);
addExactData(exactMidByteArray, exactLeadNumArray, resiBitArray, lce);
P1[index] = vce->data;
}
/* Process row-i data 1 --> data r3-1*/
for (j = 1; j < r3; j++)
{
index = i*r3+j;
pred2D = P1[index-1] + P1[index-r3] - P1[index-r3-1];
diff = spaceFillingValue[index] - pred2D;
itvNum = fabs(diff)/realPrecision + 1;
if (itvNum < intvCapacity)
{
if (diff < 0) itvNum = -itvNum;
type[index] = (int) (itvNum/2) + intvRadius;
P1[index] = pred2D + 2 * (type[index] - intvRadius) * realPrecision;
}
else
{
type[index] = 0;
addDBA_Data(resiBitLengthArray, (unsigned char)resiBitsLength);
compressSingleFloatValue(vce, spaceFillingValue[index], realPrecision, medianValue, reqLength, reqBytesLength, resiBitsLength);
updateLossyCompElement_Float(vce->curBytes, preDataBytes, reqBytesLength, resiBitsLength, lce);
memcpy(preDataBytes,vce->curBytes,4);
addExactData(exactMidByteArray, exactLeadNumArray, resiBitArray, lce);
P1[index] = vce->data;
}
}
}
/////////////////////////// Process layer-1 --> layer-r1-1 ///////////////////////////
for (k = 1; k < r1; k++)
{
/* Process Row-0 data 0*/
index = k*r23;
pred1D = P1[0];
diff = spaceFillingValue[index] - pred1D;
itvNum = fabs(diff)/realPrecision + 1;
if (itvNum < intvCapacity)
{
if (diff < 0) itvNum = -itvNum;
type[index] = (int) (itvNum/2) + intvRadius;
P0[0] = pred1D + 2 * (type[index] - intvRadius) * realPrecision;
}
else
{
type[index] = 0;
addDBA_Data(resiBitLengthArray, (unsigned char)resiBitsLength);
compressSingleFloatValue(vce, spaceFillingValue[index], realPrecision, medianValue, reqLength, reqBytesLength, resiBitsLength);
updateLossyCompElement_Float(vce->curBytes, preDataBytes, reqBytesLength, resiBitsLength, lce);
memcpy(preDataBytes,vce->curBytes,4);
addExactData(exactMidByteArray, exactLeadNumArray, resiBitArray, lce);
P0[0] = vce->data;
}
/* Process Row-0 data 1 --> data r3-1 */
for (j = 1; j < r3; j++)
{
//index = k*r2*r3+j;
index ++;
pred2D = P0[j-1] + P1[j] - P1[j-1];
diff = spaceFillingValue[index] - pred2D;
itvNum = fabs(diff)/realPrecision + 1;
if (itvNum < intvCapacity)
{
if (diff < 0) itvNum = -itvNum;
type[index] = (int) (itvNum/2) + intvRadius;
P0[j] = pred2D + 2 * (type[index] - intvRadius) * realPrecision;
/* if(type[index]==0)
printf("err:type[%d]=0, index4\n", index); */
}
else
{
type[index] = 0;
addDBA_Data(resiBitLengthArray, (unsigned char)resiBitsLength);
compressSingleFloatValue(vce, spaceFillingValue[index], realPrecision, medianValue, reqLength, reqBytesLength, resiBitsLength);
updateLossyCompElement_Float(vce->curBytes, preDataBytes, reqBytesLength, resiBitsLength, lce);
memcpy(preDataBytes,vce->curBytes,4);
addExactData(exactMidByteArray, exactLeadNumArray, resiBitArray, lce);
P0[j] = vce->data;
}
}
/* Process Row-1 --> Row-r2-1 */
int index2D;
for (i = 1; i < r2; i++)
{
/* Process Row-i data 0 */
index = k*r23 + i*r3;
index2D = i*r3;
pred2D = P0[index2D-r3] + P1[index2D] - P1[index2D-r3];
diff = spaceFillingValue[index] - pred2D;
itvNum = fabs(diff)/realPrecision + 1;
if (itvNum < intvCapacity)
{
if (diff < 0) itvNum = -itvNum;
type[index] = (int) (itvNum/2) + intvRadius;
P0[index2D] = pred2D + 2 * (type[index] - intvRadius) * realPrecision;
}
else
{
type[index] = 0;
addDBA_Data(resiBitLengthArray, (unsigned char)resiBitsLength);
compressSingleFloatValue(vce, spaceFillingValue[index], realPrecision, medianValue, reqLength, reqBytesLength, resiBitsLength);
updateLossyCompElement_Float(vce->curBytes, preDataBytes, reqBytesLength, resiBitsLength, lce);
memcpy(preDataBytes,vce->curBytes,4);
addExactData(exactMidByteArray, exactLeadNumArray, resiBitArray, lce);
P0[index2D] = vce->data;
}
/* Process Row-i data 1 --> data r3-1 */
for (j = 1; j < r3; j++)
{
// if(k==63&&i==43&&j==27)
// printf("i=%d\n", i);
//index = k*r2*r3 + i*r3 + j;
index ++;
index2D = i*r3 + j;
pred3D = P0[index2D-1] + P0[index2D-r3]+ P1[index2D] - P0[index2D-r3-1] - P1[index2D-r3] - P1[index2D-1] + P1[index2D-r3-1];
diff = spaceFillingValue[index] - pred3D;
itvNum = fabs(diff)/realPrecision + 1;
if (itvNum < intvCapacity)
{
if (diff < 0) itvNum = -itvNum;
type[index] = (int) (itvNum/2) + intvRadius;
P0[index2D] = pred3D + 2 * (type[index] - intvRadius) * realPrecision;
}
else
{
type[index] = 0;
addDBA_Data(resiBitLengthArray, (unsigned char)resiBitsLength);
compressSingleFloatValue(vce, spaceFillingValue[index], realPrecision, medianValue, reqLength, reqBytesLength, resiBitsLength);
updateLossyCompElement_Float(vce->curBytes, preDataBytes, reqBytesLength, resiBitsLength, lce);
memcpy(preDataBytes,vce->curBytes,4);
addExactData(exactMidByteArray, exactLeadNumArray, resiBitArray, lce);
P0[index2D] = vce->data;
}
}
}
float *Pt;
Pt = P1;
P1 = P0;
P0 = Pt;
}
if(r23!=1)
free(P0);
free(P1);
int exactDataNum = exactLeadNumArray->size;
TightDataPointStorageF* tdps;
new_TightDataPointStorageF(&tdps, dataLength, exactDataNum,
type, exactMidByteArray->array, exactMidByteArray->size,
exactLeadNumArray->array,
resiBitArray->array, resiBitArray->size,
resiBitLengthArray->array, resiBitLengthArray->size,
realPrecision, medianValue, (char)reqLength, quantization_intervals, NULL, 0, 0);
//sdi:Debug
/* int sum =0;
for(i=0;i<dataLength;i++)
if(type[i]==0) sum++;
printf("opt_quantizations=%d, exactDataNum=%d, sum=%d\n",quantization_intervals, exactDataNum, sum);
*/
// printf("exactDataNum=%d, expSegmentsInBytes_size=%d, exactMidByteArray->size=%d,resiBitLengthArray->size=%d\n",
// exactDataNum, expSegmentsInBytes_size, exactMidByteArray->size, resiBitLengthArray->size);
//free memory
free_DBA(resiBitLengthArray);
free_DIA(exactLeadNumArray);
free_DIA(resiBitArray);
free(type);
free(vce);
free(lce);
free(exactMidByteArray); //exactMidByteArray->array has been released in free_TightDataPointStorageF(tdps);
return tdps;
}
TightDataPointStorageF* SZ_compress_float_1D_MDQ(float *oriData,
int dataLength, double realPrecision, float valueRangeSize, float medianValue_f)
{
unsigned int quantization_intervals;
if(optQuantMode==1)
quantization_intervals = optimize_intervals_float_1D(oriData, dataLength, realPrecision);
else
quantization_intervals = intvCapacity;
updateQuantizationInfo(quantization_intervals);
//clearHuffmanMem();
int i, reqLength;
float medianValue = medianValue_f;
short reqExpo = getPrecisionReqLength_float((float)realPrecision);
short radExpo = getExponent_float(valueRangeSize/2);
computeReqLength_float(realPrecision, radExpo, &reqLength, &medianValue);
int* type = (int*) malloc(dataLength*sizeof(int));
//type[dataLength]=0;
float* spaceFillingValue = oriData; //
DynamicByteArray *resiBitLengthArray;
new_DBA(&resiBitLengthArray, DynArrayInitLen);
DynamicIntArray *exactLeadNumArray;
new_DIA(&exactLeadNumArray, DynArrayInitLen);
DynamicByteArray *exactMidByteArray;
new_DBA(&exactMidByteArray, DynArrayInitLen);
DynamicIntArray *resiBitArray;
new_DIA(&resiBitArray, DynArrayInitLen);
type[0] = 0;
unsigned char preDataBytes[4];
intToBytes_bigEndian(preDataBytes, 0);
int reqBytesLength = reqLength/8;
int resiBitsLength = reqLength%8;
float last3CmprsData[3] = {0};
FloatValueCompressElement *vce = (FloatValueCompressElement*)malloc(sizeof(FloatValueCompressElement));
LossyCompressionElement *lce = (LossyCompressionElement*)malloc(sizeof(LossyCompressionElement));
//add the first data
addDBA_Data(resiBitLengthArray, (unsigned char)resiBitsLength);
compressSingleFloatValue(vce, spaceFillingValue[0], realPrecision, medianValue, reqLength, reqBytesLength, resiBitsLength);
updateLossyCompElement_Float(vce->curBytes, preDataBytes, reqBytesLength, resiBitsLength, lce);
memcpy(preDataBytes,vce->curBytes,4);
addExactData(exactMidByteArray, exactLeadNumArray, resiBitArray, lce);
listAdd_float(last3CmprsData, vce->data);
//printf("%.30G\n",last3CmprsData[0]);
//add the second data
type[1] = 0;
addDBA_Data(resiBitLengthArray, (unsigned char)resiBitsLength);
compressSingleFloatValue(vce, spaceFillingValue[1], realPrecision, medianValue, reqLength, reqBytesLength, resiBitsLength);
updateLossyCompElement_Float(vce->curBytes, preDataBytes, reqBytesLength, resiBitsLength, lce);
memcpy(preDataBytes,vce->curBytes,4);
addExactData(exactMidByteArray, exactLeadNumArray, resiBitArray, lce);
listAdd_float(last3CmprsData, vce->data);
//printf("%.30G\n",last3CmprsData[0]);
int state;
float lcf, qcf;
double checkRadius;
float curData;
float pred;
float predAbsErr;
float min_pred, minErr, minIndex;
int a = 0;
checkRadius = (intvCapacity-1)*realPrecision;
double interval = 2*realPrecision;
for(i=2;i<dataLength;i++)
{
// if(i==6)
// printf("i=%d\n", i);
curData = spaceFillingValue[i];
pred = 2*last3CmprsData[0] - last3CmprsData[1];
//pred = last3CmprsData[0];
predAbsErr = fabs(curData - pred);
if(predAbsErr<=checkRadius)
{
state = (predAbsErr/realPrecision+1)/2;
if(curData>=pred)
{
type[i] = intvRadius+state;
pred = pred + state*interval;
}
else //curData<pred
{
type[i] = intvRadius-state;
pred = pred - state*interval;
}
/* if(type[i]==0)
printf("err:type[%d]=0\n", i);*/
listAdd_float(last3CmprsData, pred);
continue;
}
//unpredictable data processing
type[i] = 0;
addDBA_Data(resiBitLengthArray, (unsigned char)resiBitsLength);
compressSingleFloatValue(vce, curData, realPrecision, medianValue, reqLength, reqBytesLength, resiBitsLength);
updateLossyCompElement_Float(vce->curBytes, preDataBytes, reqBytesLength, resiBitsLength, lce);
memcpy(preDataBytes,vce->curBytes,4);
addExactData(exactMidByteArray, exactLeadNumArray, resiBitArray, lce);
listAdd_float(last3CmprsData, vce->data);
}//end of for
// char* expSegmentsInBytes;
// int expSegmentsInBytes_size = convertESCToBytes(esc, &expSegmentsInBytes);
int exactDataNum = exactLeadNumArray->size;
TightDataPointStorageF* tdps;
new_TightDataPointStorageF(&tdps, dataLength, exactDataNum,
type, exactMidByteArray->array, exactMidByteArray->size,
exactLeadNumArray->array,
resiBitArray->array, resiBitArray->size,
resiBitLengthArray->array, resiBitLengthArray->size,
realPrecision, medianValue, (char)reqLength, quantization_intervals, NULL, 0, 0);
//sdi:Debug
/* int sum =0;
for(i=0;i<dataLength;i++)
if(type[i]==0) sum++;
printf("opt_quantizations=%d, exactDataNum=%d, sum=%d\n",quantization_intervals, exactDataNum, sum);*/
// writeShortData(type, dataLength, "compressStateBytes.sb");
// unsigned short type_[dataLength];
// SZ_Reset();
// decode_withTree(tdps->typeArray, tdps->typeArray_size, type_);
// printf("tdps->typeArray_size=%d\n", tdps->typeArray_size);
// printf("exactDataNum=%d, expSegmentsInBytes_size=%d, exactMidByteArray->size=%d,resiBitLengthArray->size=%d\n",
// exactDataNum, expSegmentsInBytes_size, exactMidByteArray->size, resiBitLengthArray->size);
// for(i = 3800;i<3844;i++)
// printf("exactLeadNumArray->array[%d]=%d\n",i,exactLeadNumArray->array[i]);
//free memory
free_DBA(resiBitLengthArray);
free_DIA(exactLeadNumArray);
free_DIA(resiBitArray);
free(type);
free(vce);
free(lce);
free(exactMidByteArray); //exactMidByteArray->array has been released in free_TightDataPointStorageF(tdps);
return tdps;
}
