| OpenMS 2.5.0

MSNumpress.h
Go to the documentation of this file.
1 /*
2 MSNumpress.hpp
3 johan.teleman@immun.lth.se
4
5 This distribution goes under the BSD 3-clause license. If you prefer to use Apache
6 version 2.0, that is also available at https://github.com/fickludd/ms-numpress
7 Copyright (c) 2013, Johan Teleman
8 All rights reserved.
9
10 Redistribution and use in source and binary forms, with or without modification,
11 are permitted provided that the following conditions are met:
12
13 * Redistributions of source code must retain the above copyright notice, this list
14 of conditions and the following disclaimer.
15 * Redistributions in binary form must reproduce the above copyright notice, this
16 list of conditions and the following disclaimer in the documentation and/or other
17 materials provided with the distribution.
18 * Neither the name of the Lund University nor the names of its contributors may be
19 used to endorse or promote products derived from this software without specific
20 prior written permission.
21
22 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
23 EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
24 OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT
25 SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
26 SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
27 OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
28 HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
29 OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
30 SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
31 */
32 /*
33 ==================== encodeInt ====================
34 Some of the encodings described below use a integer compression referred to simply as
35
36 encodeInt()
37
38 The algorithm is similar to other variable length integer encodings,
39 such as the SQLite Variable-Length Integers encoding, but it uses half
40 bytes in its encoding procedure.
41
42 This encoding works on a 4 byte integer, by truncating initial zeros or ones.
43 If the initial (most significant) half byte is 0x0 or 0xf, the number of such
44 halfbytes starting from the most significant is stored in a halfbyte. This initial
45 count is then followed by the rest of the ints halfbytes, in little-endian order.
46 A count halfbyte c of
47
48 0 <= c <= 8 is interpreted as an initial c 0x0 halfbytes
49 9 <= c <= 15 is interpreted as an initial (c-8) 0xf halfbytes
50
51 Example:
52
53 int c rest
54 0 => 0x8
55 -1 => 0xf 0xf
56 2 => 0x7 0x2
57 23 => 0x6 0x7 0x1
58 2047 => 0x5 0xf 0xf 0xf
59
60 Note that the algorithm returns a char array in which the half bytes are
61 stored in the lower 4 bits of each element. Since the first element is a
62 count half byte, the maximal length of the encoded data is 9 half bytes
63 (1 count half byte + 8 half bytes for a 4-byte integer).
64
65 */
66
67 #pragma once
68
69 #include <cstddef>
70 #include <vector>
71
72 // defines whether to throw an exception when a number cannot be encoded safely
73 // with the given parameters
74 #ifndef MS_NUMPRESS_THROW_ON_OVERFLOW
75 #define MS_NUMPRESS_THROW_ON_OVERFLOW true
76 #endif
77
78 namespace ms {
79 namespace numpress {
80
81 namespace MSNumpress {
82
91 double optimalLinearFixedPoint(
92 const double *data,
93 size_t dataSize);
94
109 double optimalLinearFixedPointMass(
110 const double *data,
111 size_t dataSize,
112 double mass_acc);
113
134 size_t encodeLinear(
135 const double *data,
136 const size_t dataSize,
137 unsigned char *result,
138 double fixedPoint);
139
146 void encodeLinear(
147 const std::vector<double> &data,
148 std::vector<unsigned char> &result,
149 double fixedPoint);
150
165 size_t decodeLinear(
166 const unsigned char *data,
167 const size_t dataSize,
168 double *result);
169
180 void decodeLinear(
181 const std::vector<unsigned char> &data,
182 std::vector<double> &result);
183
185
186
199 size_t encodeSafe(
200 const double *data,
201 const size_t dataSize,
202 unsigned char *result);
203
204
217 size_t decodeSafe(
218 const unsigned char *data,
219 const size_t dataSize,
220 double *result);
221
223
237 size_t encodePic(
238 const double *data,
239 const size_t dataSize,
240 unsigned char *result);
241
248 void encodePic(
249 const std::vector<double> &data,
250 std::vector<unsigned char> &result);
251
266 size_t decodePic(
267 const unsigned char *data,
268 const size_t dataSize,
269 double *result);
270
281 void decodePic(
282 const std::vector<unsigned char> &data,
283 std::vector<double> &result);
284
286
287
288 double optimalSlofFixedPoint(
289 const double *data,
290 size_t dataSize);
291
305 size_t encodeSlof(
306 const double *data,
307 const size_t dataSize,
308 unsigned char *result,
309 double fixedPoint);
310
317 void encodeSlof(
318 const std::vector<double> &data,
319 std::vector<unsigned char> &result,
320 double fixedPoint);
321
334 size_t decodeSlof(
335 const unsigned char *data,
336 const size_t dataSize,
337 double *result);
338
347 void decodeSlof(
348 const std::vector<unsigned char> &data,
349 std::vector<double> &result);
350
351 } // namespace MSNumpress
352 } // namespace msdata
353 } // namespace pwiz
354
ms::numpress::MSNumpress::encodeSlof
size_t encodeSlof(const double *data, const size_t dataSize, unsigned char *result, double fixedPoint)
ms
Definition: MSNumpress.h:78
ms::numpress::MSNumpress::decodeLinear
size_t decodeLinear(const unsigned char *data, const size_t dataSize, double *result)
ms::numpress::MSNumpress::optimalLinearFixedPoint
double optimalLinearFixedPoint(const double *data, size_t dataSize)
ms::numpress::MSNumpress::encodeSafe
size_t encodeSafe(const double *data, const size_t dataSize, unsigned char *result)
ms::numpress::MSNumpress::decodeSlof
size_t decodeSlof(const unsigned char *data, const size_t dataSize, double *result)
ms::numpress::MSNumpress::decodeSafe
size_t decodeSafe(const unsigned char *data, const size_t dataSize, double *result)
ms::numpress::MSNumpress::decodePic
size_t decodePic(const unsigned char *data, const size_t dataSize, double *result)
ms::numpress::MSNumpress::optimalSlofFixedPoint
double optimalSlofFixedPoint(const double *data, size_t dataSize)
ms::numpress::MSNumpress::encodeLinear
size_t encodeLinear(const double *data, const size_t dataSize, unsigned char *result, double fixedPoint)
ms::numpress::MSNumpress::optimalLinearFixedPointMass
double optimalLinearFixedPointMass(const double *data, size_t dataSize, double mass_acc)
ms::numpress::MSNumpress::encodePic
size_t encodePic(const double *data, const size_t dataSize, unsigned char *result)