Loading...
Searching...
No Matches
Sisco.h
Go to the documentation of this file.
#ifndef SISCO_SISCO_H_
#define SISCO_SISCO_H_
#include <optional>
#include <span>
#include <vector>
#include "BitFloat.h"
namespace casacore::sisco {
struct CompressorState {
std::vector<BitFloat> previous4;
std::vector<BitFloat> previous3;
std::vector<BitFloat> previous2;
std::vector<BitFloat> previous1;
std::vector<BitFloat> scratch;
};
constexpr size_t kCompressedMantissaSize = sizeof(uint32_t);
constexpr size_t kCompressedExponentSize = sizeof(int8_t);
void DifferenceCompress1D(std::span<const BitFloat> input,
std::span<std::byte> mantissa_data,
std::span<std::byte> exponent_data);
void Average2Compress1D(std::span<const BitFloat> input,
std::span<std::byte> mantissa_data,
std::span<std::byte> exponent_data);
void LinearCompress1D(std::span<const BitFloat> input,
std::span<std::byte> mantissa_data,
std::span<std::byte> exponent_data);
void Linear3Compress1D(std::span<const BitFloat> input,
std::span<std::byte> mantissa_data,
std::span<std::byte> exponent_data);
void QuadraticCompress1D(std::span<const BitFloat> input,
std::span<std::byte> mantissa_data,
std::span<std::byte> exponent_data);
void Quadratic4Compress1D(std::span<const BitFloat> input,
std::span<std::byte> mantissa_data,
std::span<std::byte> exponent_data);
void CubicCompress1D(std::span<const BitFloat> input,
std::span<std::byte> mantissa_data,
std::span<std::byte> exponent_data);
void DifferenceDecompress1D(std::span<const std::byte> mantissa_data,
std::span<const std::byte> exponent_data,
std::span<BitFloat> output);
void Average2Decompress1D(std::span<const std::byte> mantissa_data,
std::span<const std::byte> exponent_data,
std::span<BitFloat> output);
void LinearDecompress1D(std::span<const std::byte> mantissa_data,
std::span<const std::byte> exponent_data,
std::span<BitFloat> output);
void Linear3Decompress1D(std::span<const std::byte> mantissa_data,
std::span<const std::byte> exponent_data,
std::span<BitFloat> output);
void QuadraticDecompress1D(std::span<const std::byte> mantissa_data,
std::span<const std::byte> exponent_data,
std::span<BitFloat> output);
void Quadratic4Decompress1D(std::span<const std::byte> mantissa_data,
std::span<const std::byte> exponent_data,
std::span<BitFloat> output);
void CubicDecompress1D(std::span<const std::byte> mantissa_data,
std::span<const std::byte> exponent_data,
std::span<BitFloat> output);
void DirectCompress2D(std::span<const float> row,
std::span<std::byte> mantissa_data,
std::span<std::byte> exponent_data);
void DifferenceCompress2D(CompressorState& state, std::span<const float> row,
std::span<std::byte> mantissa_data,
std::span<std::byte> exponent_data);
void Average2Compress2D(CompressorState& state, std::span<const float> row,
std::span<std::byte> mantissa_data,
std::span<std::byte> exponent_data);
void LinearCompress2D(CompressorState& state, std::span<const float> row,
std::span<std::byte> mantissa_data,
std::span<std::byte> exponent_data);
void LinearQuadraticCompress2D(CompressorState& state,
std::span<const float> row,
std::span<std::byte> mantissa_data,
std::span<std::byte> exponent_data);
void Linear3Compress2D(CompressorState& state, std::span<const float> row,
std::span<std::byte> mantissa_data,
std::span<std::byte> exponent_data);
void QuadraticCompress2D(CompressorState& state, std::span<const float> row,
std::span<std::byte> mantissa_data,
std::span<std::byte> exponent_data);
void Quadratic4Compress2D(CompressorState& state, std::span<const float> row,
std::span<std::byte> mantissa_data,
std::span<std::byte> exponent_data);
void CubicCompress2D(CompressorState& state, std::span<const float> row,
std::span<std::byte> mantissa_data,
std::span<std::byte> exponent_data);
void DirectDecompress2D(std::span<std::byte> mantissa_data,
std::span<std::byte> exponent_data,
std::span<float> row);
void DifferenceDecompress2D(CompressorState& state,
std::span<std::byte> mantissa_data,
std::span<std::byte> exponent_data,
std::span<float> row);
void Average2Decompress2D(CompressorState& state,
std::span<std::byte> mantissa_data,
std::span<std::byte> exponent_data,
std::span<float> row);
void LinearDecompress2D(CompressorState& state,
std::span<std::byte> mantissa_data,
std::span<std::byte> exponent_data,
std::span<float> row);
void LinearQuadraticDecompress2D(CompressorState& state,
std::span<std::byte> mantissa_data,
std::span<std::byte> exponent_data,
std::span<float> row);
void Linear3Decompress2D(CompressorState& state,
std::span<std::byte> mantissa_data,
std::span<std::byte> exponent_data,
std::span<float> row);
void QuadraticDecompress2D(CompressorState& state,
std::span<std::byte> mantissa_data,
std::span<std::byte> exponent_data,
std::span<float> row);
void Quadratic4Decompress2D(CompressorState& state,
std::span<std::byte> mantissa_data,
std::span<std::byte> exponent_data,
std::span<float> row);
void CubicDecompress2D(CompressorState& state,
std::span<std::byte> mantissa_data,
std::span<std::byte> exponent_data,
std::span<float> row);
size_t DefaultThreadCount();
inline void Compress1D(int level, std::span<const BitFloat> row,
std::span<std::byte> mantissa_data,
std::span<std::byte> exponent_data) {
switch (level) {
case 0:
DifferenceCompress1D(row, mantissa_data, exponent_data);
return;
case 1:
LinearCompress1D(row, mantissa_data, exponent_data);
return;
case 2:
QuadraticCompress1D(row, mantissa_data, exponent_data);
return;
case 3:
CubicCompress1D(row, mantissa_data, exponent_data);
return;
case 10:
Average2Compress1D(row, mantissa_data, exponent_data);
return;
case 11:
Linear3Compress1D(row, mantissa_data, exponent_data);
return;
case 12:
Quadratic4Compress1D(row, mantissa_data, exponent_data);
return;
}
throw std::runtime_error("Invalid compression level");
}
inline void Decompress1D(int level, std::span<std::byte> mantissa_data,
std::span<std::byte> exponent_data,
std::span<BitFloat> row) {
switch (level) {
case 0:
DifferenceDecompress1D(mantissa_data, exponent_data, row);
return;
case 1:
LinearDecompress1D(mantissa_data, exponent_data, row);
return;
case 2:
QuadraticDecompress1D(mantissa_data, exponent_data, row);
return;
case 3:
CubicDecompress1D(mantissa_data, exponent_data, row);
return;
case 10:
Average2Decompress1D(mantissa_data, exponent_data, row);
return;
case 11:
Linear3Decompress1D(mantissa_data, exponent_data, row);
return;
case 12:
Quadratic4Decompress1D(mantissa_data, exponent_data, row);
return;
}
throw std::runtime_error("Invalid compression level");
}
inline void Compress2D(int level, CompressorState& state,
std::span<const float> row,
std::span<std::byte> mantissa_data,
std::span<std::byte> exponent_data) {
switch (level) {
case -1:
DirectCompress2D(row, mantissa_data, exponent_data);
return;
case 0:
DifferenceCompress2D(state, row, mantissa_data, exponent_data);
return;
case 1:
LinearCompress2D(state, row, mantissa_data, exponent_data);
return;
case 2:
QuadraticCompress2D(state, row, mantissa_data, exponent_data);
return;
case 3:
CubicCompress2D(state, row, mantissa_data, exponent_data);
return;
case 10:
Average2Compress2D(state, row, mantissa_data, exponent_data);
return;
case 11:
Linear3Compress2D(state, row, mantissa_data, exponent_data);
return;
case 12:
Quadratic4Compress2D(state, row, mantissa_data, exponent_data);
return;
case 21:
LinearQuadraticCompress2D(state, row, mantissa_data, exponent_data);
return;
}
throw std::runtime_error("Invalid compression level");
}
inline void Decompress2D(int level, CompressorState& state,
std::span<std::byte> mantissa_data,
std::span<std::byte> exponent_data,
std::span<float> row) {
switch (level) {
case -1:
DirectDecompress2D(mantissa_data, exponent_data, row);
return;
case 0:
DifferenceDecompress2D(state, mantissa_data, exponent_data, row);
return;
case 1:
LinearDecompress2D(state, mantissa_data, exponent_data, row);
return;
case 2:
QuadraticDecompress2D(state, mantissa_data, exponent_data, row);
return;
case 3:
CubicDecompress2D(state, mantissa_data, exponent_data, row);
return;
case 10:
Average2Decompress2D(state, mantissa_data, exponent_data, row);
return;
case 11:
Linear3Decompress2D(state, mantissa_data, exponent_data, row);
return;
case 12:
Quadratic4Decompress2D(state, mantissa_data, exponent_data, row);
return;
case 21:
LinearQuadraticDecompress2D(state, mantissa_data, exponent_data, row);
return;
}
throw std::runtime_error("Invalid compression level");
}
inline constexpr BitFloat PredictThreshold(const BitFloat& value) {
if (value.Mantissa() & 0xFE000000)
return BitFloat(0, value.Exponent(), false);
else
return value;
}
inline constexpr BitFloat Predict(const BitFloat& previous,
int8_t value_exponent) {
if (!previous.AllowsMath()) {
return BitFloat(0, value_exponent, false);
} else if (previous.Exponent() == value_exponent) {
return previous;
} else if (previous.Exponent() > value_exponent) {
// Shift predicted mantissa left to have same exponent
const uint8_t shift = previous.Exponent() - value_exponent;
if (shift > 1)
return BitFloat(0, value_exponent, false);
else {
const BitFloat result(previous.Mantissa() << shift, value_exponent,
previous.Sign());
return PredictThreshold(result);
}
} else {
// Shift predicted mantissa right to have same exponent
const uint8_t shift = value_exponent - previous.Exponent();
if (shift > 24)
return BitFloat(0, value_exponent, false);
else
return BitFloat(previous.Mantissa() >> shift, value_exponent,
previous.Sign());
}
}
inline constexpr BitFloat Residual(const BitFloat& previous,
const BitFloat& value) {
const BitFloat predict = Predict(previous, value.Exponent());
BitFloat residual = value;
residual -= predict;
return residual;
}
inline constexpr BitFloat Predict(const BitFloat& previous2,
const BitFloat& previous1,
int8_t value_exponent) {
if (!previous1.AllowsMath()) {
return Predict(previous2, value_exponent);
} else if (!previous2.AllowsMath()) {
return Predict(previous1, value_exponent);
} else if (!BitFloat::AllowsMath(value_exponent)) {
return BitFloat(0, value_exponent, false);
} else {
const std::optional<BitFloat> matched_p2 = Match(previous2, value_exponent);
if (!matched_p2) return BitFloat(0, value_exponent, false);
std::optional<BitFloat> result = Match(previous1, value_exponent);
if (!result) return BitFloat(0, value_exponent, false);
(*result) *= 2;
(*result) -= *matched_p2;
return PredictThreshold(*result);
}
}
inline constexpr BitFloat Residual(const BitFloat& previous2,
const BitFloat& previous1,
const BitFloat& value) {
const BitFloat predict = Predict(previous2, previous1, value.Exponent());
BitFloat residual = value;
residual -= predict;
return residual;
}
inline constexpr BitFloat AveragePredict(const BitFloat& previous2,
const BitFloat& previous1,
int8_t value_exponent) {
if (!previous1.AllowsMath()) {
return Predict(previous2, value_exponent);
} else if (!previous2.AllowsMath()) {
return Predict(previous1, value_exponent);
} else if (!BitFloat::AllowsMath(value_exponent)) {
return BitFloat(0, value_exponent, false);
} else {
const std::optional<BitFloat> matched_p2 = Match(previous2, value_exponent);
if (!matched_p2) return BitFloat(0, value_exponent, false);
std::optional<BitFloat> result = Match(previous1, value_exponent);
if (!result) return BitFloat(0, value_exponent, false);
(*result) += *matched_p2;
(*result) /= 2;
return PredictThreshold(*result);
}
}
inline constexpr BitFloat Predict(const BitFloat& previous3,
const BitFloat& previous2,
const BitFloat& previous1,
int8_t value_exponent) {
if (!previous1.AllowsMath()) {
return Predict(previous2, value_exponent);
} else if (!previous2.AllowsMath()) {
return Predict(previous1, value_exponent);
} else if (!previous3.AllowsMath()) {
return Predict(previous2, previous1, value_exponent);
} else if (!BitFloat::AllowsMath(value_exponent)) {
return BitFloat(0, value_exponent, false);
} else {
const std::optional<BitFloat> matched_p3 = Match(previous3, value_exponent);
if (!matched_p3) return Predict(previous2, previous1, value_exponent);
std::optional<BitFloat> matched_p2 = Match(previous2, value_exponent);
if (!matched_p2) return Predict(previous1, value_exponent);
std::optional<BitFloat> result = Match(previous1, value_exponent);
if (!result) return Predict(previous2, value_exponent);
// We have to calculate:
// p1 + dp12 + (dp12 - dp23)
// = p1 + (p1 - p2) + (p1 - p2) - (p2 - p3)
// = 3p1 - 3p2 + p3
(*result) *= 3;
(*matched_p2) *= 3;
(*result) -= *matched_p2;
(*result) += *matched_p3;
return PredictThreshold(*result);
}
}
inline constexpr BitFloat LinearPredict(const BitFloat& previous3,
const BitFloat& previous2,
const BitFloat& previous1,
int8_t value_exponent) {
if (!previous1.AllowsMath()) {
return Predict(previous2, value_exponent);
} else if (!previous2.AllowsMath()) {
return Predict(previous1, value_exponent);
} else if (!previous3.AllowsMath()) {
return Predict(previous2, previous1, value_exponent);
} else if (!BitFloat::AllowsMath(value_exponent)) {
return BitFloat(0, value_exponent, false);
} else {
std::optional<BitFloat> matched_p3 = Match(-previous3, value_exponent);
if (!matched_p3) return Predict(previous2, previous1, value_exponent);
const std::optional<BitFloat> matched_p2 = Match(previous2, value_exponent);
if (!matched_p2) return Predict(previous1, value_exponent);
std::optional<BitFloat> result = Match(previous1, value_exponent);
if (!result) return Predict(previous2, value_exponent);
// We have to calculate:
// ( -2 p3 + p2 + 4 p1 ) / 3
// Note that sign of p3 was already flipped
(*result) *= 4;
(*result) += *matched_p2;
(*matched_p3) *= 2;
(*result) += *matched_p3;
(*result) /= 3;
return PredictThreshold(*result);
}
}
inline constexpr BitFloat Predict(const BitFloat& previous4,
const BitFloat& previous3,
const BitFloat& previous2,
const BitFloat& previous1,
int8_t value_exponent) {
if (!previous1.AllowsMath()) {
return Predict(previous2, value_exponent);
} else if (!previous2.AllowsMath()) {
return Predict(previous1, value_exponent);
} else if (!previous3.AllowsMath()) {
return Predict(previous2, previous1, value_exponent);
} else if (!previous4.AllowsMath()) {
return Predict(previous3, previous2, previous1, value_exponent);
} else if (!BitFloat::AllowsMath(value_exponent)) {
return BitFloat(0, value_exponent, false);
} else {
const std::optional<BitFloat> matched_p4 = Match(previous4, value_exponent);
if (!matched_p4)
return Predict(previous3, previous2, previous1, value_exponent);
std::optional<BitFloat> matched_p3 = Match(previous3, value_exponent);
if (!matched_p3) return Predict(previous2, previous1, value_exponent);
std::optional<BitFloat> matched_p2 = Match(previous2, value_exponent);
if (!matched_p2) return Predict(previous1, value_exponent);
std::optional<BitFloat> result = Match(previous1, value_exponent);
if (!result) return Predict(previous2, value_exponent);
// We have to calculate:
// p_next = -p4 + 4p3 - 6p2 + 4p1
(*result) *= 4;
(*matched_p2) *= 6;
(*result) -= *matched_p2;
(*matched_p3) *= 4;
(*result) += *matched_p3;
(*result) -= *matched_p4;
return PredictThreshold(*result);
}
}
inline constexpr BitFloat QuadraticPredict(const BitFloat& previous4,
const BitFloat& previous3,
const BitFloat& previous2,
const BitFloat& previous1,
int8_t value_exponent) {
if (!previous1.AllowsMath()) {
return Predict(previous2, value_exponent);
} else if (!previous2.AllowsMath()) {
return Predict(previous1, value_exponent);
} else if (!previous3.AllowsMath()) {
return Predict(previous2, previous1, value_exponent);
} else if (!previous4.AllowsMath()) {
return Predict(previous3, previous2, previous1, value_exponent);
} else if (!BitFloat::AllowsMath(value_exponent)) {
return BitFloat(0, value_exponent, false);
} else {
std::optional<BitFloat> matched_p4 = Match(previous4, value_exponent);
if (!matched_p4)
return Predict(previous3, previous2, previous1, value_exponent);
std::optional<BitFloat> matched_p3 = Match(previous3, value_exponent);
if (!matched_p3) return Predict(previous2, previous1, value_exponent);
std::optional<BitFloat> matched_p2 = Match(previous2, value_exponent);
if (!matched_p2) return Predict(previous1, value_exponent);
std::optional<BitFloat> result = Match(previous1, value_exponent);
if (!result) return Predict(previous2, value_exponent);
// We have to calculate:
// p_next = ( 3p4 - 5p3 - 3p2 + 9p1 ) / 4
(*result) *= 9;
(*matched_p2) *= 3;
(*result) -= *matched_p2;
(*matched_p3) *= 5;
(*result) -= *matched_p3;
(*matched_p4) *= 3;
(*result) += *matched_p4;
(*result) /= 4;
return PredictThreshold(*result);
}
}
} // namespace casacore::sisco
#endif
BitFloat.h
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:122
casacore::BitFloat::Exponent
constexpr int8_t Exponent() const
Definition BitFloat.h:75
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:216
casacore::BitFloat::Mantissa
constexpr uint32_t Mantissa() const
Definition BitFloat.h:73
casacore::sisco
Definition ConditionalQueue.h:8
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:305
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:220
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:488
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:332
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:369
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:162
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:420
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:256
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:298
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:191
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:369
casacore::sisco::CompressorState
Definition Sisco.h:12
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