casacore
Loading...
Searching...
No Matches
Sisco.h
Go to the documentation of this file.
1#ifndef SISCO_SISCO_H_
2#define SISCO_SISCO_H_
3
4#include <optional>
5#include <span>
6#include <vector>
7
8#include "BitFloat.h"
9
10namespace casacore::sisco {
11
12struct CompressorState {
13 std::vector<BitFloat> previous4;
14 std::vector<BitFloat> previous3;
15 std::vector<BitFloat> previous2;
16 std::vector<BitFloat> previous1;
17 std::vector<BitFloat> scratch;
18};
19
20constexpr size_t kCompressedMantissaSize = sizeof(uint32_t);
21constexpr size_t kCompressedExponentSize = sizeof(int8_t);
22
23void DifferenceCompress1D(std::span<const BitFloat> input, std::span<std::byte> mantissa_data,
24 std::span<std::byte> exponent_data);
25
26void Average2Compress1D(std::span<const BitFloat> input, std::span<std::byte> mantissa_data,
27 std::span<std::byte> exponent_data);
28
29void LinearCompress1D(std::span<const BitFloat> input, std::span<std::byte> mantissa_data,
30 std::span<std::byte> exponent_data);
31
32void Linear3Compress1D(std::span<const BitFloat> input, std::span<std::byte> mantissa_data,
33 std::span<std::byte> exponent_data);
34
35void QuadraticCompress1D(std::span<const BitFloat> input, std::span<std::byte> mantissa_data,
36 std::span<std::byte> exponent_data);
37
38void Quadratic4Compress1D(std::span<const BitFloat> input, std::span<std::byte> mantissa_data,
39 std::span<std::byte> exponent_data);
40
41void CubicCompress1D(std::span<const BitFloat> input, std::span<std::byte> mantissa_data,
42 std::span<std::byte> exponent_data);
43
44void DifferenceDecompress1D(std::span<const std::byte> mantissa_data,
45 std::span<const std::byte> exponent_data, std::span<BitFloat> output);
46
47void Average2Decompress1D(std::span<const std::byte> mantissa_data,
48 std::span<const std::byte> exponent_data, std::span<BitFloat> output);
49
50void LinearDecompress1D(std::span<const std::byte> mantissa_data,
51 std::span<const std::byte> exponent_data, std::span<BitFloat> output);
52
53void Linear3Decompress1D(std::span<const std::byte> mantissa_data,
54 std::span<const std::byte> exponent_data, std::span<BitFloat> output);
55
56void QuadraticDecompress1D(std::span<const std::byte> mantissa_data,
57 std::span<const std::byte> exponent_data, std::span<BitFloat> output);
58
59void Quadratic4Decompress1D(std::span<const std::byte> mantissa_data,
60 std::span<const std::byte> exponent_data, std::span<BitFloat> output);
61
62void CubicDecompress1D(std::span<const std::byte> mantissa_data,
63 std::span<const std::byte> exponent_data, std::span<BitFloat> output);
64
65void DirectCompress2D(std::span<const float> row, std::span<std::byte> mantissa_data,
66 std::span<std::byte> exponent_data);
67
68void DifferenceCompress2D(CompressorState& state, std::span<const float> row,
69 std::span<std::byte> mantissa_data, std::span<std::byte> exponent_data);
70
71void Average2Compress2D(CompressorState& state, std::span<const float> row,
72 std::span<std::byte> mantissa_data, std::span<std::byte> exponent_data);
73
74void LinearCompress2D(CompressorState& state, std::span<const float> row,
75 std::span<std::byte> mantissa_data, std::span<std::byte> exponent_data);
76
77void LinearQuadraticCompress2D(CompressorState& state, std::span<const float> row,
78 std::span<std::byte> mantissa_data,
79 std::span<std::byte> exponent_data);
80
81void Linear3Compress2D(CompressorState& state, std::span<const float> row,
82 std::span<std::byte> mantissa_data, std::span<std::byte> exponent_data);
83
84void QuadraticCompress2D(CompressorState& state, std::span<const float> row,
85 std::span<std::byte> mantissa_data, std::span<std::byte> exponent_data);
86
87void Quadratic4Compress2D(CompressorState& state, std::span<const float> row,
88 std::span<std::byte> mantissa_data, std::span<std::byte> exponent_data);
89
90void CubicCompress2D(CompressorState& state, std::span<const float> row,
91 std::span<std::byte> mantissa_data, std::span<std::byte> exponent_data);
92
93void DirectDecompress2D(std::span<std::byte> mantissa_data, std::span<std::byte> exponent_data,
94 std::span<float> row);
95
96void DifferenceDecompress2D(CompressorState& state, std::span<std::byte> mantissa_data,
97 std::span<std::byte> exponent_data, std::span<float> row);
98
99void Average2Decompress2D(CompressorState& state, std::span<std::byte> mantissa_data,
100 std::span<std::byte> exponent_data, std::span<float> row);
101
102void LinearDecompress2D(CompressorState& state, std::span<std::byte> mantissa_data,
103 std::span<std::byte> exponent_data, std::span<float> row);
104
105void LinearQuadraticDecompress2D(CompressorState& state, std::span<std::byte> mantissa_data,
106 std::span<std::byte> exponent_data, std::span<float> row);
107
108void Linear3Decompress2D(CompressorState& state, std::span<std::byte> mantissa_data,
109 std::span<std::byte> exponent_data, std::span<float> row);
110
111void QuadraticDecompress2D(CompressorState& state, std::span<std::byte> mantissa_data,
112 std::span<std::byte> exponent_data, std::span<float> row);
113
114void Quadratic4Decompress2D(CompressorState& state, std::span<std::byte> mantissa_data,
115 std::span<std::byte> exponent_data, std::span<float> row);
116
117void CubicDecompress2D(CompressorState& state, std::span<std::byte> mantissa_data,
118 std::span<std::byte> exponent_data, std::span<float> row);
119
120size_t DefaultThreadCount();
121
122inline void Compress1D(int level, std::span<const BitFloat> row, std::span<std::byte> mantissa_data,
123 std::span<std::byte> exponent_data) {
124 switch (level) {
125 case 0:
126 DifferenceCompress1D(row, mantissa_data, exponent_data);
127 return;
128 case 1:
129 LinearCompress1D(row, mantissa_data, exponent_data);
130 return;
131 case 2:
132 QuadraticCompress1D(row, mantissa_data, exponent_data);
133 return;
134 case 3:
135 CubicCompress1D(row, mantissa_data, exponent_data);
136 return;
137 case 10:
138 Average2Compress1D(row, mantissa_data, exponent_data);
139 return;
140 case 11:
141 Linear3Compress1D(row, mantissa_data, exponent_data);
142 return;
143 case 12:
144 Quadratic4Compress1D(row, mantissa_data, exponent_data);
145 return;
146 }
147 throw std::runtime_error("Invalid compression level");
148}
149
150inline void Decompress1D(int level, std::span<std::byte> mantissa_data,
151 std::span<std::byte> exponent_data, std::span<BitFloat> row) {
152 switch (level) {
153 case 0:
154 DifferenceDecompress1D(mantissa_data, exponent_data, row);
155 return;
156 case 1:
157 LinearDecompress1D(mantissa_data, exponent_data, row);
158 return;
159 case 2:
160 QuadraticDecompress1D(mantissa_data, exponent_data, row);
161 return;
162 case 3:
163 CubicDecompress1D(mantissa_data, exponent_data, row);
164 return;
165 case 10:
166 Average2Decompress1D(mantissa_data, exponent_data, row);
167 return;
168 case 11:
169 Linear3Decompress1D(mantissa_data, exponent_data, row);
170 return;
171 case 12:
172 Quadratic4Decompress1D(mantissa_data, exponent_data, row);
173 return;
174 }
175 throw std::runtime_error("Invalid compression level");
176}
177
178inline void Compress2D(int level, CompressorState& state, std::span<const float> row,
179 std::span<std::byte> mantissa_data, std::span<std::byte> exponent_data) {
180 switch (level) {
181 case -1:
182 DirectCompress2D(row, mantissa_data, exponent_data);
183 return;
184 case 0:
185 DifferenceCompress2D(state, row, mantissa_data, exponent_data);
186 return;
187 case 1:
188 LinearCompress2D(state, row, mantissa_data, exponent_data);
189 return;
190 case 2:
191 QuadraticCompress2D(state, row, mantissa_data, exponent_data);
192 return;
193 case 3:
194 CubicCompress2D(state, row, mantissa_data, exponent_data);
195 return;
196 case 10:
197 Average2Compress2D(state, row, mantissa_data, exponent_data);
198 return;
199 case 11:
200 Linear3Compress2D(state, row, mantissa_data, exponent_data);
201 return;
202 case 12:
203 Quadratic4Compress2D(state, row, mantissa_data, exponent_data);
204 return;
205 case 21:
206 LinearQuadraticCompress2D(state, row, mantissa_data, exponent_data);
207 return;
208 }
209 throw std::runtime_error("Invalid compression level");
210}
211
212inline void Decompress2D(int level, CompressorState& state, std::span<std::byte> mantissa_data,
213 std::span<std::byte> exponent_data, std::span<float> row) {
214 switch (level) {
215 case -1:
216 DirectDecompress2D(mantissa_data, exponent_data, row);
217 return;
218 case 0:
219 DifferenceDecompress2D(state, mantissa_data, exponent_data, row);
220 return;
221 case 1:
222 LinearDecompress2D(state, mantissa_data, exponent_data, row);
223 return;
224 case 2:
225 QuadraticDecompress2D(state, mantissa_data, exponent_data, row);
226 return;
227 case 3:
228 CubicDecompress2D(state, mantissa_data, exponent_data, row);
229 return;
230 case 10:
231 Average2Decompress2D(state, mantissa_data, exponent_data, row);
232 return;
233 case 11:
234 Linear3Decompress2D(state, mantissa_data, exponent_data, row);
235 return;
236 case 12:
237 Quadratic4Decompress2D(state, mantissa_data, exponent_data, row);
238 return;
239 case 21:
240 LinearQuadraticDecompress2D(state, mantissa_data, exponent_data, row);
241 return;
242 }
243 throw std::runtime_error("Invalid compression level");
244}
245
252inline constexpr BitFloat PredictThreshold(const BitFloat& value) {
253 if (value.Mantissa() & 0xFE000000)
254 return BitFloat(0, value.Exponent(), false);
255 else
256 return value;
257}
258
259inline constexpr BitFloat Predict(const BitFloat& previous, int8_t value_exponent) {
260 if (!previous.AllowsMath()) {
261 return BitFloat(0, value_exponent, false);
262 } else if (previous.Exponent() == value_exponent) {
263 return previous;
264 } else if (previous.Exponent() > value_exponent) {
265 // Shift predicted mantissa left to have same exponent
266 const uint8_t shift = previous.Exponent() - value_exponent;
267 if (shift > 1)
268 return BitFloat(0, value_exponent, false);
269 else {
270 const BitFloat result(previous.Mantissa() << shift, value_exponent, previous.Sign());
271 return PredictThreshold(result);
272 }
273 } else {
274 // Shift predicted mantissa right to have same exponent
275 const uint8_t shift = value_exponent - previous.Exponent();
276 if (shift > 24)
277 return BitFloat(0, value_exponent, false);
278 else
279 return BitFloat(previous.Mantissa() >> shift, value_exponent, previous.Sign());
280 }
281}
282
283inline constexpr BitFloat Residual(const BitFloat& previous, const BitFloat& value) {
284 const BitFloat predict = Predict(previous, value.Exponent());
285 BitFloat residual = value;
286 residual -= predict;
287 return residual;
288}
289
290inline constexpr BitFloat Predict(const BitFloat& previous2, const BitFloat& previous1,
291 int8_t value_exponent) {
292 if (!previous1.AllowsMath()) {
293 return Predict(previous2, value_exponent);
294 } else if (!previous2.AllowsMath()) {
295 return Predict(previous1, value_exponent);
296 } else if (!BitFloat::AllowsMath(value_exponent)) {
297 return BitFloat(0, value_exponent, false);
298 } else {
299 const std::optional<BitFloat> matched_p2 = Match(previous2, value_exponent);
300 if (!matched_p2) return BitFloat(0, value_exponent, false);
301 std::optional<BitFloat> result = Match(previous1, value_exponent);
302 if (!result) return BitFloat(0, value_exponent, false);
303 (*result) *= 2;
304 (*result) -= *matched_p2;
305 return PredictThreshold(*result);
306 }
307}
308
309inline constexpr BitFloat Residual(const BitFloat& previous2, const BitFloat& previous1,
310 const BitFloat& value) {
311 const BitFloat predict = Predict(previous2, previous1, value.Exponent());
312 BitFloat residual = value;
313 residual -= predict;
314 return residual;
315}
316
317inline constexpr BitFloat AveragePredict(const BitFloat& previous2, const BitFloat& previous1,
318 int8_t value_exponent) {
319 if (!previous1.AllowsMath()) {
320 return Predict(previous2, value_exponent);
321 } else if (!previous2.AllowsMath()) {
322 return Predict(previous1, value_exponent);
323 } else if (!BitFloat::AllowsMath(value_exponent)) {
324 return BitFloat(0, value_exponent, false);
325 } else {
326 const std::optional<BitFloat> matched_p2 = Match(previous2, value_exponent);
327 if (!matched_p2) return BitFloat(0, value_exponent, false);
328 std::optional<BitFloat> result = Match(previous1, value_exponent);
329 if (!result) return BitFloat(0, value_exponent, false);
330 (*result) += *matched_p2;
331 (*result) /= 2;
332 return PredictThreshold(*result);
333 }
334}
335
336inline constexpr BitFloat Predict(const BitFloat& previous3, const BitFloat& previous2,
337 const BitFloat& previous1, int8_t value_exponent) {
338 if (!previous1.AllowsMath()) {
339 return Predict(previous2, value_exponent);
340 } else if (!previous2.AllowsMath()) {
341 return Predict(previous1, value_exponent);
342 } else if (!previous3.AllowsMath()) {
343 return Predict(previous2, previous1, value_exponent);
344 } else if (!BitFloat::AllowsMath(value_exponent)) {
345 return BitFloat(0, value_exponent, false);
346 } else {
347 const std::optional<BitFloat> matched_p3 = Match(previous3, value_exponent);
348 if (!matched_p3) return Predict(previous2, previous1, value_exponent);
349 std::optional<BitFloat> matched_p2 = Match(previous2, value_exponent);
350 if (!matched_p2) return Predict(previous1, value_exponent);
351 std::optional<BitFloat> result = Match(previous1, value_exponent);
352 if (!result) return Predict(previous2, value_exponent);
353 // We have to calculate:
354 // p1 + dp12 + (dp12 - dp23)
355 // = p1 + (p1 - p2) + (p1 - p2) - (p2 - p3)
356 // = 3p1 - 3p2 + p3
357 (*result) *= 3;
358 (*matched_p2) *= 3;
359 (*result) -= *matched_p2;
360 (*result) += *matched_p3;
361 return PredictThreshold(*result);
362 }
363}
364
365inline constexpr BitFloat LinearPredict(const BitFloat& previous3, const BitFloat& previous2,
366 const BitFloat& previous1, int8_t value_exponent) {
367 if (!previous1.AllowsMath()) {
368 return Predict(previous2, value_exponent);
369 } else if (!previous2.AllowsMath()) {
370 return Predict(previous1, value_exponent);
371 } else if (!previous3.AllowsMath()) {
372 return Predict(previous2, previous1, value_exponent);
373 } else if (!BitFloat::AllowsMath(value_exponent)) {
374 return BitFloat(0, value_exponent, false);
375 } else {
376 std::optional<BitFloat> matched_p3 = Match(-previous3, value_exponent);
377 if (!matched_p3) return Predict(previous2, previous1, value_exponent);
378 const std::optional<BitFloat> matched_p2 = Match(previous2, value_exponent);
379 if (!matched_p2) return Predict(previous1, value_exponent);
380 std::optional<BitFloat> result = Match(previous1, value_exponent);
381 if (!result) return Predict(previous2, value_exponent);
382 // We have to calculate:
383 // ( -2 p3 + p2 + 4 p1 ) / 3
384 // Note that sign of p3 was already flipped
385 (*result) *= 4;
386 (*result) += *matched_p2;
387 (*matched_p3) *= 2;
388 (*result) += *matched_p3;
389 (*result) /= 3;
390 return PredictThreshold(*result);
391 }
392}
393
394inline constexpr BitFloat Predict(const BitFloat& previous4, const BitFloat& previous3,
395 const BitFloat& previous2, const BitFloat& previous1,
396 int8_t value_exponent) {
397 if (!previous1.AllowsMath()) {
398 return Predict(previous2, value_exponent);
399 } else if (!previous2.AllowsMath()) {
400 return Predict(previous1, value_exponent);
401 } else if (!previous3.AllowsMath()) {
402 return Predict(previous2, previous1, value_exponent);
403 } else if (!previous4.AllowsMath()) {
404 return Predict(previous3, previous2, previous1, value_exponent);
405 } else if (!BitFloat::AllowsMath(value_exponent)) {
406 return BitFloat(0, value_exponent, false);
407 } else {
408 const std::optional<BitFloat> matched_p4 = Match(previous4, value_exponent);
409 if (!matched_p4) return Predict(previous3, previous2, previous1, value_exponent);
410 std::optional<BitFloat> matched_p3 = Match(previous3, value_exponent);
411 if (!matched_p3) return Predict(previous2, previous1, value_exponent);
412 std::optional<BitFloat> matched_p2 = Match(previous2, value_exponent);
413 if (!matched_p2) return Predict(previous1, value_exponent);
414 std::optional<BitFloat> result = Match(previous1, value_exponent);
415 if (!result) return Predict(previous2, value_exponent);
416 // We have to calculate:
417 // p_next = -p4 + 4p3 - 6p2 + 4p1
418 (*result) *= 4;
419 (*matched_p2) *= 6;
420 (*result) -= *matched_p2;
421 (*matched_p3) *= 4;
422 (*result) += *matched_p3;
423 (*result) -= *matched_p4;
424 return PredictThreshold(*result);
425 }
426}
427
428inline constexpr BitFloat QuadraticPredict(const BitFloat& previous4, const BitFloat& previous3,
429 const BitFloat& previous2, const BitFloat& previous1,
430 int8_t value_exponent) {
431 if (!previous1.AllowsMath()) {
432 return Predict(previous2, value_exponent);
433 } else if (!previous2.AllowsMath()) {
434 return Predict(previous1, value_exponent);
435 } else if (!previous3.AllowsMath()) {
436 return Predict(previous2, previous1, value_exponent);
437 } else if (!previous4.AllowsMath()) {
438 return Predict(previous3, previous2, previous1, value_exponent);
439 } else if (!BitFloat::AllowsMath(value_exponent)) {
440 return BitFloat(0, value_exponent, false);
441 } else {
442 std::optional<BitFloat> matched_p4 = Match(previous4, value_exponent);
443 if (!matched_p4) return Predict(previous3, previous2, previous1, value_exponent);
444 std::optional<BitFloat> matched_p3 = Match(previous3, value_exponent);
445 if (!matched_p3) return Predict(previous2, previous1, value_exponent);
446 std::optional<BitFloat> matched_p2 = Match(previous2, value_exponent);
447 if (!matched_p2) return Predict(previous1, value_exponent);
448 std::optional<BitFloat> result = Match(previous1, value_exponent);
449 if (!result) return Predict(previous2, value_exponent);
450 // We have to calculate:
451 // p_next = ( 3p4 - 5p3 - 3p2 + 9p1 ) / 4
452 (*result) *= 9;
453 (*matched_p2) *= 3;
454 (*result) -= *matched_p2;
455 (*matched_p3) *= 5;
456 (*result) -= *matched_p3;
457 (*matched_p4) *= 3;
458 (*result) += *matched_p4;
459 (*result) /= 4;
460 return PredictThreshold(*result);
461 }
462}
463
464} // namespace casacore::sisco
465
466#endif
casacore::BitFloat
Class that understands the bit-representation of single-precision floating point numbers,...
Definition BitFloat.h:54
casacore::BitFloat::Sign
constexpr bool Sign() const
Definition BitFloat.h:116
casacore::BitFloat::Exponent
constexpr int8_t Exponent() const
Definition BitFloat.h:73
casacore::BitFloat::AllowsMath
static constexpr bool AllowsMath(int8_t exponent)
Based on the exponent, determines if this is a special value and should not be used in mathematical o...
Definition BitFloat.h:209
casacore::BitFloat::Mantissa
constexpr uint32_t Mantissa() const
Definition BitFloat.h:71
casacore::sisco::DirectCompress2D
void DirectCompress2D(std::span< const float > row, std::span< std::byte > mantissa_data, std::span< std::byte > exponent_data)
casacore::sisco::LinearQuadraticDecompress2D
void LinearQuadraticDecompress2D(CompressorState &state, std::span< std::byte > mantissa_data, std::span< std::byte > exponent_data, std::span< float > row)
casacore::sisco::Linear3Decompress1D
void Linear3Decompress1D(std::span< const std::byte > mantissa_data, std::span< const std::byte > exponent_data, std::span< BitFloat > output)
casacore::sisco::CubicCompress2D
void CubicCompress2D(CompressorState &state, std::span< const float > row, std::span< std::byte > mantissa_data, std::span< std::byte > exponent_data)
casacore::sisco::Predict
constexpr BitFloat Predict(const BitFloat &previous, int8_t value_exponent)
Definition Sisco.h:259
casacore::sisco::Compress2D
void Compress2D(int level, CompressorState &state, std::span< const float > row, std::span< std::byte > mantissa_data, std::span< std::byte > exponent_data)
Definition Sisco.h:178
casacore::sisco::DirectDecompress2D
void DirectDecompress2D(std::span< std::byte > mantissa_data, std::span< std::byte > exponent_data, std::span< float > row)
casacore::sisco::Linear3Decompress2D
void Linear3Decompress2D(CompressorState &state, std::span< std::byte > mantissa_data, std::span< std::byte > exponent_data, std::span< float > row)
casacore::sisco::QuadraticPredict
constexpr BitFloat QuadraticPredict(const BitFloat &previous4, const BitFloat &previous3, const BitFloat &previous2, const BitFloat &previous1, int8_t value_exponent)
Definition Sisco.h:428
casacore::sisco::DifferenceDecompress2D
void DifferenceDecompress2D(CompressorState &state, std::span< std::byte > mantissa_data, std::span< std::byte > exponent_data, std::span< float > row)
casacore::sisco::kCompressedExponentSize
constexpr size_t kCompressedExponentSize
Definition Sisco.h:21
casacore::sisco::QuadraticDecompress2D
void QuadraticDecompress2D(CompressorState &state, std::span< std::byte > mantissa_data, std::span< std::byte > exponent_data, std::span< float > row)
casacore::sisco::Residual
constexpr BitFloat Residual(const BitFloat &previous, const BitFloat &value)
Definition Sisco.h:283
casacore::sisco::DifferenceCompress2D
void DifferenceCompress2D(CompressorState &state, std::span< const float > row, std::span< std::byte > mantissa_data, std::span< std::byte > exponent_data)
casacore::sisco::CubicDecompress1D
void CubicDecompress1D(std::span< const std::byte > mantissa_data, std::span< const std::byte > exponent_data, std::span< BitFloat > output)
casacore::sisco::QuadraticCompress2D
void QuadraticCompress2D(CompressorState &state, std::span< const float > row, std::span< std::byte > mantissa_data, std::span< std::byte > exponent_data)
casacore::sisco::AveragePredict
constexpr BitFloat AveragePredict(const BitFloat &previous2, const BitFloat &previous1, int8_t value_exponent)
Definition Sisco.h:317
casacore::sisco::Quadratic4Decompress1D
void Quadratic4Decompress1D(std::span< const std::byte > mantissa_data, std::span< const std::byte > exponent_data, std::span< BitFloat > output)
casacore::sisco::DefaultThreadCount
size_t DefaultThreadCount()
casacore::sisco::Compress1D
void Compress1D(int level, std::span< const BitFloat > row, std::span< std::byte > mantissa_data, std::span< std::byte > exponent_data)
Definition Sisco.h:122
casacore::sisco::kCompressedMantissaSize
constexpr size_t kCompressedMantissaSize
Definition Sisco.h:20
casacore::sisco::LinearCompress1D
void LinearCompress1D(std::span< const BitFloat > input, std::span< std::byte > mantissa_data, std::span< std::byte > exponent_data)
casacore::sisco::Linear3Compress1D
void Linear3Compress1D(std::span< const BitFloat > input, std::span< std::byte > mantissa_data, std::span< std::byte > exponent_data)
casacore::sisco::QuadraticDecompress1D
void QuadraticDecompress1D(std::span< const std::byte > mantissa_data, std::span< const std::byte > exponent_data, std::span< BitFloat > output)
casacore::sisco::LinearPredict
constexpr BitFloat LinearPredict(const BitFloat &previous3, const BitFloat &previous2, const BitFloat &previous1, int8_t value_exponent)
Definition Sisco.h:365
casacore::sisco::LinearQuadraticCompress2D
void LinearQuadraticCompress2D(CompressorState &state, std::span< const float > row, std::span< std::byte > mantissa_data, std::span< std::byte > exponent_data)
casacore::sisco::QuadraticCompress1D
void QuadraticCompress1D(std::span< const BitFloat > input, std::span< std::byte > mantissa_data, std::span< std::byte > exponent_data)
casacore::sisco::Decompress2D
void Decompress2D(int level, CompressorState &state, std::span< std::byte > mantissa_data, std::span< std::byte > exponent_data, std::span< float > row)
Definition Sisco.h:212
casacore::sisco::PredictThreshold
constexpr BitFloat PredictThreshold(const BitFloat &value)
If the predicted value is approximately twice as large as the target value (based on its exponent onl...
Definition Sisco.h:252
casacore::sisco::Quadratic4Compress1D
void Quadratic4Compress1D(std::span< const BitFloat > input, std::span< std::byte > mantissa_data, std::span< std::byte > exponent_data)
casacore::sisco::LinearDecompress2D
void LinearDecompress2D(CompressorState &state, std::span< std::byte > mantissa_data, std::span< std::byte > exponent_data, std::span< float > row)
casacore::sisco::Quadratic4Compress2D
void Quadratic4Compress2D(CompressorState &state, std::span< const float > row, std::span< std::byte > mantissa_data, std::span< std::byte > exponent_data)
casacore::sisco::Decompress1D
void Decompress1D(int level, std::span< std::byte > mantissa_data, std::span< std::byte > exponent_data, std::span< BitFloat > row)
Definition Sisco.h:150
casacore::sisco::DifferenceDecompress1D
void DifferenceDecompress1D(std::span< const std::byte > mantissa_data, std::span< const std::byte > exponent_data, std::span< BitFloat > output)
casacore::sisco::LinearDecompress1D
void LinearDecompress1D(std::span< const std::byte > mantissa_data, std::span< const std::byte > exponent_data, std::span< BitFloat > output)
casacore::sisco::Average2Decompress1D
void Average2Decompress1D(std::span< const std::byte > mantissa_data, std::span< const std::byte > exponent_data, std::span< BitFloat > output)
casacore::sisco::Linear3Compress2D
void Linear3Compress2D(CompressorState &state, std::span< const float > row, std::span< std::byte > mantissa_data, std::span< std::byte > exponent_data)
casacore::sisco::CubicCompress1D
void CubicCompress1D(std::span< const BitFloat > input, std::span< std::byte > mantissa_data, std::span< std::byte > exponent_data)
casacore::sisco::CubicDecompress2D
void CubicDecompress2D(CompressorState &state, std::span< std::byte > mantissa_data, std::span< std::byte > exponent_data, std::span< float > row)
casacore::sisco::Average2Decompress2D
void Average2Decompress2D(CompressorState &state, std::span< std::byte > mantissa_data, std::span< std::byte > exponent_data, std::span< float > row)
casacore::sisco::DifferenceCompress1D
void DifferenceCompress1D(std::span< const BitFloat > input, std::span< std::byte > mantissa_data, std::span< std::byte > exponent_data)
casacore::sisco::LinearCompress2D
void LinearCompress2D(CompressorState &state, std::span< const float > row, std::span< std::byte > mantissa_data, std::span< std::byte > exponent_data)
casacore::sisco::Average2Compress1D
void Average2Compress1D(std::span< const BitFloat > input, std::span< std::byte > mantissa_data, std::span< std::byte > exponent_data)
casacore::sisco::Quadratic4Decompress2D
void Quadratic4Decompress2D(CompressorState &state, std::span< std::byte > mantissa_data, std::span< std::byte > exponent_data, std::span< float > row)
casacore::sisco::Average2Compress2D
void Average2Compress2D(CompressorState &state, std::span< const float > row, std::span< std::byte > mantissa_data, std::span< std::byte > exponent_data)
casacore::value
NewDelAllocator< T > NewDelAllocator< T >::value
Definition Allocator.h:360
casacore::sisco::CompressorState::previous1
std::vector< BitFloat > previous1
Definition Sisco.h:16
casacore::sisco::CompressorState::scratch
std::vector< BitFloat > scratch
Definition Sisco.h:17
casacore::sisco::CompressorState::previous2
std::vector< BitFloat > previous2
Definition Sisco.h:15
casacore::sisco::CompressorState::previous3
std::vector< BitFloat > previous3
Definition Sisco.h:14
casacore::sisco::CompressorState::previous4
std::vector< BitFloat > previous4
Definition Sisco.h:13
Generated by doxygen 1.15.0