Error-bound floating-point data compression system

Abstract

A system includes receiving a plurality of original floating point values, rounding each of the plurality of original floating point values ​​to a corresponding rounded floating point value, wherein each rounded floating point value is within an error bound of its corresponding original floating point value, compressing the plurality of rounded floating point values, and storing the plurality of compressed rounded floating point values ​​in a data storage system.

Description

Background Art

[0001] Modern computing deployments generate large amounts of data. The storage of this data consumes a large amount of computing resources. Data compression techniques can be used to reduce the amount of data stored, and therefore also reduce the resources required to store the data.

[0002] Data compression can be lossless, where the original data can be exactly reproduced from the compressed data, or lossy, where there is no guarantee that the original data can be exactly reproduced from the compressed data. Lossy compression typically exhibits higher compression ratios and / or faster processing than lossless compression. The compression technique applied in a particular situation depends on the error tolerance of the situation and the type of data being compressed.

[0003] Systems such as the Internet of Things (IoT) architecture may generate floating point data. For example, an IoT sensor may provide temperature data that, after conversion from Celsius to Fahrenheit, is represented as a 64-bit double precision value. Therefore, this data needs to be compressed before storage. Furthermore, due to known accuracy limitations of IoT sensors, it may be permissible to store these values ​​such that decompression will result in a maximum error bound of 0.01 for each value.

[0004] For example, given an error margin of 0.01, it would be assumed that the values ​​{1.241, 1.240, 1.239, 1.241, 1.253} are to be stored. According to known methods for lossy floating point compression, the first four values ​​are identified as being within the error margin of the same value (i.e., 1.24), and thus these values ​​are stored as {4x1.24, 1x1.253} (e.g., a "run" array of {4, 1} and a "value" array of {1.24, 1.253}). However, if consecutive values ​​vary significantly relative to the error bound (e.g., {1.2348903, 3.489345, -21.2344903, ...}), known methods store the data as {1x1.2348903, 1x3.489345, 1x-21.2344903...} (e.g., as a "run" array {1, 1, 1, ...} and a "value" array {1.2348903, 3.4489345, -21.2344903, ...}), which does not provide satisfactory compression.

[0005] Improvements in error-bound floating-point compression are desirable. BRIEF DESCRIPTION OF THE DRAWINGS

[0006] Figure 1 Illustrated is an architecture for generating, compressing, storing, and retrieving floating point values ​​according to some embodiments.

[0007] Figure 2is a tabular representation of floating point sensor values ​​according to some embodiments.

[0008] Figure 3 According to some embodiments Figure 2 Tabular representation of a double-precision version of the sensor value.

[0009] Figure 4 is a flow chart of a process for rounding floating point values ​​based on an error bound, according to some embodiments.

[0010] Figure 5 According to some embodiments Figure 2 Tabular representation of a rounded version of the sensor value.

[0011] Figure 6 A processing pipeline for compressing floating point values ​​is illustrated in accordance with some embodiments.

[0012] Figure 7 A processing pipeline for compressing floating point values ​​is illustrated in accordance with some embodiments.

[0013] Figure 8 A processing pipeline for compressing floating point values ​​is illustrated in accordance with some embodiments.

[0014] Fig. 9 is a flow chart of a process for rounding floating point values ​​based on an error bound and a sum of values, according to some embodiments.

[0015] Fig.10 is a flow chart of a process for rounding floating point values ​​based on an error bound and a sum of values, according to some embodiments.

[0016] Fig.11 is a block diagram of a computing system according to some embodiments. DETAILED DESCRIPTION

[0017] The following description is provided to enable any person skilled in the art to make and use the described embodiments, and sets forth the best mode contemplated for carrying out some embodiments. However, various modifications will be apparent to those skilled in the art.

[0018] Embodiments involve rounding each of a plurality of floating point values ​​to a specific number of decimal places. Each of the rounded values ​​is within a specified error bound of its original value. The rounded values ​​are then subjected to further floating point compression, which in turn may include integer compression according to some embodiments. Some embodiments further operate to reduce or eliminate the difference of the sum of the error bounded rounded values ​​relative to the sum of the corresponding original floating point values.

[0019] Thus, some embodiments may provide improved error bound compression of input floating point values ​​that exhibit a significant number of decimal places and / or a large variance in continuous values ​​relative to the error bound.

[0020] Figure 1 An architecture 100 is illustrated in accordance with some embodiments. The architecture 100 includes sensors 110a-110d, each of which provides floating point values ​​to a stream processor 120. The sensors 110a-110d may include any type and / or number of sensors and may provide data to the stream processor 120 upon request, asynchronously, and / or according to any schedule or criteria. The stream processor 120 may include a processing component (e.g., an IoT hub) capable of receiving IoT data and processing it as needed. Embodiments are not limited to floating point values ​​generated by sensors or processed by stream processors.

[0021] According to the illustrated example, the stream processor 120 sends the received floating point value to the database platform 130 for storage. Before sending to the database platform, the stream processor 120 can compress the data as described herein.

[0022] Database platform 130 includes a database management system (DBMS) 132 and a data store 134. DBMS 132 may compress data as described herein prior to storage in data store 134, and decompress the data thus stored prior to providing the data to a requester. DBMS 132 may also perform administrative and management functions of database platform 130. Such functions may include snapshot and backup management, indexing, optimization, garbage collection, and / or any other known or to-be-known database functions.

[0023] The data store 134 may include any storage system for storing data in any format that is known or becomes known. The data store 134 may include data of a database table and metadata describing the data structure, but the embodiment is not limited thereto. The data of the data store 134 may include one or more of conventional tabular data, row-based data, column-based data, and object-based data. In addition, the data may be indexed and / or selectively repeated in an index to allow rapid searching and retrieval thereof.

[0024] The database platform 130 may implement an "in-memory" database, where the complete database is stored in volatile (e.g., non-disk-based) memory (e.g., random access memory). The complete database may be persisted in and / or backed up to a fixed disk (not shown). Embodiments are not limited to an in-memory implementation. For example, data may be stored in random access memory (e.g., a cache memory for storing recently used data) and one or more fixed disks (e.g., persistent storage for storing their respective portions of the entire database).

[0025] The query server 140 can process structured query language (SQL) and multidimensional expressions (MDX) statements received from a database application (not shown). The processing can include the generation and execution of a query execution plan to retrieve data from the data store 134. As described above, the DBMS 132 can decompress the retrieved data before sending it to the query server 140.

[0026] Figure 2 is a tabular representation of floating point sensor values ​​200 that may be compressed according to some embodiments. The sensor values ​​200 may be received from any suitable source or sources, and embodiments are not limited to values ​​generated by sensors. For comparison purposes, Figure 3 is a tabular representation of double precision values ​​300 corresponding to sensor values ​​200 according to some embodiments. Embodiments may attempt to compress values ​​such as sensor values ​​200 into a storage space of less than 64 bits per value while maintaining specified error bounds.

[0027] Figure 4 4 is a flow chart of a process 400 for rounding floating point values ​​based on an error bound according to some embodiments. In some non-exhaustive embodiments, various hardware elements of the database system execute program code to perform process 400. Process 400 and all other processes mentioned herein can be implemented as a processor executable program code read from one or more of a non-transitory computer readable medium such as a hard drive, a volatile or non-volatile random access memory, a DVD-ROM, a flash drive, and a tape, and then stored in a compressed, uncompiled and / or encrypted format. In some embodiments, hard-wired circuits can be used instead of program code or in combination with program code to implement processes according to some embodiments. Embodiments are not limited to any specific combination of hardware and software.

[0028] Initially, a plurality of raw floating point values ​​are received at S405. The plurality of floating point values ​​may be received or obtained from any known or becoming known source. Each of the plurality of raw floating point values ​​may include a positive value or a negative value, and each of the plurality of raw floating point values ​​may include any number of decimal places.

[0029] According to some embodiments, an indication of an error bound or quantization error is also received at S405. The error bound may indicate a maximum per-value error that may be exhibited by the values ​​obtained by process 400. Thus, S405 may include receiving a command to compress a set of floating point values ​​in view of a specific error bound.

[0030] In some embodiments, the components performing process 400 are aware of applicable error limits. For example, in the case of architecture 100, DBMS 132 may receive a command at S405 to store a plurality of floating point values. DBMS 132 then independently determines to perform the remainder of process 400 to compress and store floating point values ​​in view of the predetermined error limits.

[0031] At S410, each of the plurality of original floating point values ​​is rounded to a specific number (ie, N) of decimal places. According to the example currently described, N is initially set to a small number. The embodiments are not limited thereto, and these alternative embodiments will be described below.

[0032] More specifically, it will be assumed that multiple primitive floating-point values ​​are Figure 2 The sensor value 200 is rounded to a value with zero decimal places. Thus, {1.24225, 1.25121, 1.2639, 1.2692} is rounded to {1, 1, 1, 1}. According to some embodiments, the rounding may be performed using a "scaling factor" such that rounded_value=round(original_value*scaling_factor) / scaling factor. Using an initial scaling factor of 1 (corresponding to N=0) at S410, rounded_value=round(1.24225*1) / 1=1.

[0033] Next, at S415, determine whether each rounded value is within the specified error of its corresponding original value. Mathematically, for each original value, S415 evaluates whether |original_value-rounded_value|<0.01 is true. With reference to this example, S415 determines whether |1.24225-1|<0.01, |1.25121-1|<0.01, |1.2639-1|<0.01, |1.2692-1|<0.01 are all true. In other embodiments, S415 may include determining a maximum value (original_value-rounded_value) and comparing the maximum value with an error limit. In any case, and because the above inequality is not true, the determination at S415 in the above example is negative.

[0034] If the determination at S415 is negative, the flow proceeds to S420. At S420, it is determined whether N has reached a maximum pre-specified value. In the event that the number of decimal places required to meet the error bound is greater than the number of decimal places expected, or if one or more of the original values ​​is such that the error bound cannot be met regardless of the number of decimal places (e.g., Inf) to which the value is rounded, S420 provides an exit from process 400.

[0035] Therefore, if the determination at S420 is affirmative, the flow proceeds to S435 to simply output the original floating point value.

[0036] If N has not reached the maximum pre-specified value, the flow proceeds from S420 to S425 to increment N. Then, each of the plurality of original floating point values ​​is rounded to an increasing number of decimal places at S410 .

[0037] Assuming that N is now equal to 1, rounding can be performed at S410 using a scaling factor of 10. For example, rounded_value=round(1.24225*10) / 10=1.2, rounded_value=round(1.25121*10) / 10=1.3, rounded_value=round(1.2639*10) / 10=1.3, and rounded_value=round(1.2692*10) / 10=1.3. The corresponding errors for each rounded value are {0.04225, 0.04879, 0.0361, 0.0308}. Since all of these values ​​are greater than 0.01, the subsequent determination at S415 is negative, and the process returns to S420.

[0038] N is incremented to 2 at S425, corresponding to a scaling factor of 100. Therefore, at S410, rounded_value=round(1.24225*100) / 100=1.24, rounded_value=round(1.25121*100) / 100=1.25, rounded_value=round(1.2639*100) / 100=1.26, and rounded_value=round(1.2692*100) / 100=1.27. The corresponding errors for each rounded value are {0.00225, 0.00121, 0.0039, 0.0008}. Therefore, at S415, it is determined that each rounded value is within 0.01 of its original value.

[0039] The flow proceeds from S415 to S430 to output the rounded value. Referring to the above example, the output value is {1.24, 1.25, 1.26, 1.27}. Figure 5 is a tabular representation of output rounded values ​​500 according to some embodiments.

[0040] As described above, some embodiments of S410 use a larger initial value (e.g., 20) for N. Therefore, the affirmative determination at S415 causes N to be decremented, and rounding is performed at S410 based on the decremented value. The flow continues in this manner until the determination at S415 is negative, in which case the output rounded value is a value corresponding to the previous value of N (and the corresponding scaling factor).

[0041] The output rounded floating point values ​​can then be further compressed. Using the output rounded floating point values ​​instead of the original floating point values ​​may result in higher compression ratios than other lossy floating point compression techniques.

[0042] Figures 6 to 8 A processing pipeline for compressing floating point values ​​according to some embodiments is illustrated. The illustrated pipeline can be implemented in any system where compression of floating point values ​​is desired. The embodiments are not limited to the illustrated pipeline.

[0043] Pipeline 600 includes an error bound rounding component 610 to receive a floating point value. Component 610 can perform process 400 on the received floating point value to generate and output a rounded floating point value, as described above. Component 610 can also receive an error bound value for use in process 400. Figures 6 to 8 Component 610 and each of the other components may include one or more processing units that execute program code.

[0044] The floating point compression component 620 receives the rounded floating point value from the rounding component 610 and performs compression to generate and output a compressed floating point value. The compressed floating point value can be stored and / or sent as needed. The floating point compression component 620 can perform any type of lossless or lossy floating point compression that is known or becomes known.

[0045] According to some embodiments, Figure 7 The pipeline 700 of FIG. 700 may include a specific implementation of the pipeline 600. The error bound rounding component 710 may perform the process 400 as described above. The integer conversion component 720 and the integer compression component 730 may perform floating point compression together. For example, the integer conversion component 720 may convert the rounded value output by the rounding component 710 into an integer value. Since the rounded values ​​may each exhibit the same number of decimal places N, the integer conversion component 720 may determine the scaling factor 10. N , which is then multiplied by each rounded value to generate multiple integer values.

[0046] The integer compression component 730 receives a plurality of integer values ​​and a scaling factor. The component 730 may compress the integer values ​​using any integer compression algorithm that is known or becomes known. The algorithm may include a combination of algorithms, such as, but not limited to, compression, run-length compression, and delta compression. As is known, the combination may depend on the specific integer values ​​being compressed and / or their relationship to each other.

[0047] Figure 8 The pipeline 800 including the error limit rounding component 810 is illustrated, and the component can perform process 400 to generate multiple rounded floating point values. As described in the above background technology, the rounded floating point value can be adaptively approximated by component 820. For example, if the rounded value output by component 810 is {1.241, 1.240, 1.239, 1.241, 1.253}, and the error limit is 0.01 lossy compression to be performed by component 820, then the value is output as "run" array {4, 1} and "value" array {1.24, 1.253}. Then, the run array can be integer compressed by integer compression component 830 to generate a compressed run array, and the value array can be floating-point compressed by floating-point compression component 840 to generate a compressed value array. The floating-point compression of component 840 can be continued as described above with respect to components 720 and 730, but embodiments are not limited thereto.

[0048] Fig. 9 is a flow chart of a process 900 for rounding floating point values ​​based on an error bound and a sum of values ​​according to some embodiments. In some scenarios, process 900 can be performed on rounded values ​​output by process 400. For example, any of the components 610, 710, and 810 described above can perform process 400 and then perform process 900 to compress multiple floating point values ​​based on an error bound and a sum of compressed values.

[0049] To illustrate the relevance of the sum of values, consider the following multiple values ​​to be compressed: {1.24, 1.24, 1.24, 1.24, 1.24, 1.24, 1.24, 1.24, 1.24, 1.24}. The average is 1.24, and the sum of these values ​​is 12.4. Given an error bound of 0.1, using process 400 to compress the values, the resulting rounded values ​​would be {1.2, 1.2, 1.2, 1.2, 1.2, 1.2, 1.2, 1.2, 1.2, 1.2, 1.2}, with an average of 1.2 and a sum of 12. Therefore, if the rounded values ​​are stored in place of the original values, certain accumulation calculations on the stored data will result in a different solution than if the aggregation calculations were performed on the original data.

[0050] The following rounded values ​​are also within an error bound of 0.1 of the original values: {1.2, 1.2, 1.2, 1.2, 1.2, 1.2, 1.3, 1.3, 1.3, 1.3}. As with the original values, the average of these values ​​is 1.24 and the sum is 12.4. Therefore, in some contexts, the second set of rounded values ​​can be considered a closer representation of the original values. For example, certain cumulative calculations on the second set of rounded values ​​may result in a solution that is more similar to the solution that would be generated if the calculations were applied to the original values.

[0051] Assume that before process 900, the plurality of original floating point values ​​have been compressed into a plurality of rounded floating point values ​​having N decimal places, for example, by process 400. Process 900 starts at S905, where the values ​​M and sum_approx are initialized to 1 and 0, respectively.

[0052] Next, at S910, the Nth decimal place of the Mth (i.e., first) rounding value is incremented to generate an incremented rounding value, and decremented to generate a decremented rounding value. For example, assuming N=2, and the first rounding value is 1.23, the first increment value is 1.24, and the first decrement value is 1.22.

[0053] At S915, one of the first rounding value, the first incrementing value, and the first decrementing value is selected. The selected value is a value within the error limit of the Mth original value, and for the selected value, sum_approx+the selected value is closest to the sum of the first M original floating-point values. In the case of the first iteration of S915, the selected value is simply a value within the error limit and closest to the first original value. Returning to the example above, if the original value is 1.2349 and the error limit is 0.01, the first incrementing value 1.24 is within the error limit, and the first decrementing value 1.22 is not within the error limit. The difference between the first incrementing value (1.24) and the original value (1.2349) is .0051, and the difference between the first rounding value (1.23) and the original value (1.2349) is .0049. Therefore, the first rounding value (1.23) is selected at S915.

[0054] The selected value will be added to sum_approx to generate a new running sum of the selected value. S925 determines whether there is a next rounding value of the multiple rounding values. If so, M is incremented by 1 at S930, and the process returns to S910 to increment the Nth decimal place of the Mth (i.e., second) rounding value to generate a second incremented rounding value, and decrement the Nth decimal place of the Mth (i.e., second) rounding value to generate a second decremented rounding value.

[0055] With respect to the second rounding, incrementing and decrementing values, S915 is continued as described above. One of these values ​​is selected, the selected one is within the error limit of the second original value (the second rounding value will be within the error limit by virtue of process 400), and for which the new sum_approx+selected value is closest to the sum of the first two original floating point values. The flow then continues to S920 as described above.

[0056] Therefore, the process loops from S910 to S930 until it is determined at S925 that the last rounded value of the plurality of rounded values ​​has been processed. Next, at S935, each of the M values ​​selected during the M iterations of S915 is output. As described above, the output values ​​will be within the error bounds of their corresponding original values, and the sum of the original values ​​may be closer to the sum of the output values ​​than the sum of the rounded values ​​input to the process 900.

[0057] Fig.10 is a flow chart of a process 1000 for rounding floating point values ​​based on an error bound and a sum of values ​​according to some embodiments. Unlike process 900, the sum of the output values ​​of process 1000 is intended to be equal to the sum of the original plurality of non-rounded floating point values.

[0058] For a given plurality of rounded input values ​​V, for the first to V-1 values, the process 1000 selects at S1015 the same values ​​as those selected at S915 of the process 900. However, once it is determined at S1025 that the last rounded value V still needs to be processed, the flow continues to S1035. At S1035, a value is determined for which the sum of all selected values ​​will equal the sum of the plurality of original floating point values. In other words, the determined value is the difference between the sum of the plurality of original floating point values ​​and sum_approx at that time. The selected M values ​​and the value determined at S1035 are output at S1040.

[0059] The value determined at S1035 may include any number of decimal places and may be stored as a different type (e.g., double precision) and undergo different compression than the output selected M value. In the case of running process 400+1000 on a block of 10,000 input values, one such correction value will be stored for every 10,000 entries.

[0060] Fig.11 1 is a block diagram of a database system 1100 according to some embodiments. The database system 1100 may include a general purpose computing device and may execute program code to perform any of the functions described herein. In some embodiments, the database system 1100 may include an implementation of the database platform 130. According to some embodiments, the database system 1100 may include other elements not shown.

[0061] The database system 1100 includes a processing unit(s) 1110 operatively coupled to an I / O device 1120, a data storage device 1130, one or more input devices 1140, one or more output devices 1150, and a memory 1160. The I / O device 1120 may facilitate communication with an external device, such as a streaming hub, a client device, or a data storage device. The input device(s) 1140 may include, for example, a keyboard, a keypad, a mouse or other pointing device, a microphone, a knob or switch, an infrared (IR) port, a docking station, and / or a touch screen. The input device(s) 1140 may, for example, be used to input information into the system 1100. The output device(s) 1150 may include, for example, a display (e.g., a screen), a speaker, and / or a printer.

[0062] Data storage device 1130 may include any suitable persistent storage device, including a combination of magnetic storage devices (e.g., magnetic tape, hard drives, and flash memory), optical storage devices, read-only memory (ROM) devices, etc., and memory 1160 may include random access memory (RAM).

[0063] The database application, query server, and database management system of the data storage device may each include program code executed by the processing unit(s) 1110 to cause the system 1100 to perform any one or more of the processes described herein. Embodiments are not limited to a single computing device performing these processes.

[0064] The data stored in the device 1130 may include known database tables. The database tables (cached databases or complete databases) may be stored in volatile memory, such as volatile memory 1160. The data storage device 1130 may also store data and other program code to provide additional functionality and / or functionality necessary for the operation of the system 1100, such as device drivers, operating system files, etc.

[0065] Foregoing figure represents the logical framework for describing process according to some embodiments, and actual implementation can include more or different components arranged in other ways.Other topologies can be used in combination with other embodiments.In addition, each component or device described herein can be realized by any number of devices of other public and / or private network communication via any number.Two or more such computing devices can be placed away from each other, and can communicate with each other via any known (multiple) network mode and / or dedicated connection.Each component or device can include any number of hardware and / or software elements suitable for providing the function described herein and any other function.For example, any computing device used in the implementation of some embodiments can include a processor to execute program code so that the computing device is operated as described herein.

[0066] The embodiments described herein are for illustration purposes only. Those skilled in the art will appreciate that other embodiments can be practiced by modifying and substituting the embodiments described above.

Claims

1. A system comprising: A memory storing a processor executable program code; and A processing unit executes the processor executable program code so that the system: Receives multiple primitive floating point values; rounding each of the plurality of original floating point values ​​to a corresponding rounded floating point value, wherein each rounded floating point value is within a pre-specified error bound of its corresponding original floating point value; and compressing the plurality of rounded floating point values; Wherein, rounding each of the plurality of original floating-point values ​​to a corresponding rounded floating-point value comprises: rounding each of the plurality of original floating point values ​​to a respective first rounded floating point value having a first number of decimal places; determining whether each first rounded floating point value is within a pre-specified error bound of its corresponding original floating point value; and If it is determined that not each first rounded floating point value is within the pre-specified error bounds of its corresponding original floating point value: rounding each of the plurality of original floating point values ​​to a respective second rounded floating point value having a second number of decimal places, and A determination is made as to whether each second rounded floating point value is within the pre-specified error bound of its corresponding original floating point value.

2. The system according to claim 1, wherein: Compressing the plurality of rounded floating point values ​​comprises: converting each of the plurality of rounded floating point values ​​to an integer value; and Integer compression is performed on the plurality of integer values.

3. The system according to claim 1, wherein: Compressing the plurality of rounded floating point values ​​comprises: Adaptive piecewise compression is performed on the plurality of rounded floating point values.

4. The system according to claim 1, wherein the processing unit executes the processor executable program code so that the system: Based on the sum of the plurality of original floating point values, one or more rounded floating point values ​​of the plurality of rounded floating point values ​​are modified, wherein: Each of the modified one or more rounded floating point values ​​of the plurality of rounded floating point values ​​is within the pre-specified error bound of its corresponding original floating point value.

5. The system according to claim 4, wherein the processing unit executes the processor executable program code so that the system: A rounded floating-point value among the plurality of rounded floating-point values ​​is modified so that a sum of the plurality of original floating-point values ​​is equal to a sum of the modified one or more rounded floating-point values ​​among the plurality of rounded floating-point values ​​and the modified one rounded floating-point value among the plurality of rounded floating-point values ​​and any unmodified rounded floating-point values ​​among the plurality of rounded floating-point values.

6. The system according to claim 5, wherein: The number of bits of a modified one of the plurality of rounded floating-point values ​​is greater than the number of bits of each of the modified one or more of the plurality of rounded floating-point values ​​and any unmodified rounded floating-point values ​​of the plurality of rounded floating-point values.

7. A computer-implemented method comprising: Receives multiple primitive floating point values; Acceptance error margin; rounding each of the plurality of original floating point values ​​to a corresponding rounded floating point value, wherein each rounded floating point value is within the error bound of its corresponding original floating point value; and storing the plurality of rounded floating point values ​​in a compressed format; Wherein, rounding each of the plurality of original floating-point values ​​to a corresponding rounded floating-point value comprises: rounding each of the plurality of original floating point values ​​to a respective first rounded floating point value having a first number of decimal places; determining whether each first rounded floating point value is within a pre-specified error bound of its corresponding original floating point value; and If it is determined that not each first rounded floating point value is within the pre-specified error bounds of its corresponding original floating point value: rounding each of the plurality of original floating point values ​​to a respective second rounded floating point value having a second number of decimal places, and A determination is made as to whether each second rounded floating point value is within the pre-specified error bound of its corresponding original floating point value.

8. The method according to claim 7, wherein: Storage includes: converting each of the plurality of rounded floating point values ​​to an integer value; and Integer compression is performed on the plurality of integer values.

9. The method according to claim 7, wherein: Storage includes: Adaptive piecewise compression is performed on the plurality of rounded floating point values.

10. The method according to claim 7, further comprising: One or more rounded floating point values ​​of the plurality of rounded floating point values ​​are modified based on the sum of the plurality of original floating point values, wherein each of the modified one or more rounded floating point values ​​of the plurality of rounded floating point values ​​is within a pre-specified error bound of its corresponding original floating point value.

11. The method according to claim 10, further comprising: A rounded floating-point value among the plurality of rounded floating-point values ​​is modified so that a sum of the plurality of original floating-point values ​​is equal to a sum of the modified one or more rounded floating-point values ​​among the plurality of rounded floating-point values ​​and the modified one rounded floating-point value among the plurality of rounded floating-point values ​​and any unmodified rounded floating-point value among the plurality of rounded floating-point values.

12. The method according to claim 11, wherein: The number of bits of a modified one of the plurality of rounded floating-point values ​​is greater than the number of bits of each of the modified one or more of the plurality of rounded floating-point values ​​and any unmodified rounded floating-point values ​​of the plurality of rounded floating-point values.

13. A system comprising: Database server; and Data storage systems, The database server will: receiving an instruction to store a plurality of raw floating point values ​​within an error bound; In response to the instruction, rounding each of the plurality of original floating point values ​​to a corresponding rounded floating point value, wherein each rounded floating point value is within the error bound of its corresponding original floating point value; and compressing the plurality of rounded floating point values; and storing the plurality of compressed rounded floating point values ​​in the data storage system; Wherein, rounding each of the plurality of original floating-point values ​​to a corresponding rounded floating-point value comprises: rounding each of the plurality of original floating point values ​​to a respective first rounded floating point value having a first number of decimal places; determining whether each first rounded floating point value is within a pre-specified error bound of its corresponding original floating point value; and If it is determined that not each first rounded floating point value is within the pre-specified error bounds of its corresponding original floating point value: rounding each of the plurality of original floating point values ​​to a respective second rounded floating point value having a second number of decimal places, and A determination is made as to whether each second rounded floating point value is within the pre-specified error bound of its corresponding original floating point value.

14. The system according to claim 13, wherein: Compressing the plurality of rounded floating point values ​​comprises: converting each of the plurality of rounded floating point values ​​to an integer value; and Integer compression is performed on the plurality of integer values.

15. The system of claim 13, wherein: Compressing the plurality of rounded floating point values ​​comprises: Adaptive piecewise compression is performed on the plurality of rounded floating point values.

16. The system according to claim 13, wherein the database server: Based on the sum of the plurality of original floating point values, one or more rounded floating point values ​​of the plurality of rounded floating point values ​​are modified, wherein: Each of the modified one or more rounded floating point values ​​of the plurality of rounded floating point values ​​is within a pre-specified error bound of its corresponding original floating point value.

17. The system according to claim 16, wherein the database server: A rounded floating-point value among the plurality of rounded floating-point values ​​is modified so that a sum of the plurality of original floating-point values ​​is equal to a sum of the modified one or more rounded floating-point values ​​among the plurality of rounded floating-point values, the modified one rounded floating-point value among the plurality of rounded floating-point values, and any unmodified rounded floating-point value among the plurality of rounded floating-point values.

Images