// Copyright (c) 2015-2016 The Khronos Group Inc. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef LIBSPIRV_UTIL_HEX_FLOAT_H_ #define LIBSPIRV_UTIL_HEX_FLOAT_H_ #include <cassert> #include <cctype> #include <cmath> #include <cstdint> #include <iomanip> #include <limits> #include <sstream> #include "bitutils.h" namespace spvutils { class Float16 { … }; // To specialize this type, you must override uint_type to define // an unsigned integer that can fit your floating point type. // You must also add a isNan function that returns true if // a value is Nan. template <typename T> struct FloatProxyTraits { … }; template <> struct FloatProxyTraits<float> { … }; template <> struct FloatProxyTraits<double> { … }; template <> struct FloatProxyTraits<Float16> { … }; // Since copying a floating point number (especially if it is NaN) // does not guarantee that bits are preserved, this class lets us // store the type and use it as a float when necessary. template <typename T> class FloatProxy { … }; template <typename T> bool operator==(const FloatProxy<T>& first, const FloatProxy<T>& second) { … } // Reads a FloatProxy value as a normal float from a stream. template <typename T> std::istream& operator>>(std::istream& is, FloatProxy<T>& value) { … } // This is an example traits. It is not meant to be used in practice, but will // be the default for any non-specialized type. template <typename T> struct HexFloatTraits { … }; // Traits for IEEE float. // 1 sign bit, 8 exponent bits, 23 fractional bits. template <> struct HexFloatTraits<FloatProxy<float>> { … }; // Traits for IEEE double. // 1 sign bit, 11 exponent bits, 52 fractional bits. template <> struct HexFloatTraits<FloatProxy<double>> { … }; // Traits for IEEE half. // 1 sign bit, 5 exponent bits, 10 fractional bits. template <> struct HexFloatTraits<FloatProxy<Float16>> { … }; enum round_direction { … }; // Template class that houses a floating pointer number. // It exposes a number of constants based on the provided traits to // assist in interpreting the bits of the value. template <typename T, typename Traits = HexFloatTraits<T>> class HexFloat { public: typedef typename Traits::uint_type uint_type; typedef typename Traits::int_type int_type; typedef typename Traits::underlying_type underlying_type; typedef typename Traits::native_type native_type; explicit HexFloat(T f) : … { … } T value() const { … } void set_value(T f) { … } // These are all written like this because it is convenient to have // compile-time constants for all of these values. // Pass-through values to save typing. static const uint32_t num_used_bits = Traits::num_used_bits; static const uint32_t exponent_bias = Traits::exponent_bias; static const uint32_t num_exponent_bits = Traits::num_exponent_bits; static const uint32_t num_fraction_bits = Traits::num_fraction_bits; // Number of bits to shift left to set the highest relevant bit. static const uint32_t top_bit_left_shift = num_used_bits - 1; // How many nibbles (hex characters) the fractional part takes up. static const uint32_t fraction_nibbles = (num_fraction_bits + 3) / 4; // If the fractional part does not fit evenly into a hex character (4-bits) // then we have to left-shift to get rid of leading 0s. This is the amount // we have to shift (might be 0). static const uint32_t num_overflow_bits = fraction_nibbles * 4 - num_fraction_bits; // The representation of the fraction, not the actual bits. This // includes the leading bit that is usually implicit. static const uint_type fraction_represent_mask = spvutils::SetBits<uint_type, 0, num_fraction_bits + num_overflow_bits>::get; // The topmost bit in the nibble-aligned fraction. static const uint_type fraction_top_bit = uint_type(1) << (num_fraction_bits + num_overflow_bits - 1); // The least significant bit in the exponent, which is also the bit // immediately to the left of the significand. static const uint_type first_exponent_bit = uint_type(1) << (num_fraction_bits); // The mask for the encoded fraction. It does not include the // implicit bit. static const uint_type fraction_encode_mask = spvutils::SetBits<uint_type, 0, num_fraction_bits>::get; // The bit that is used as a sign. static const uint_type sign_mask = uint_type(1) << top_bit_left_shift; // The bits that represent the exponent. static const uint_type exponent_mask = spvutils::SetBits<uint_type, num_fraction_bits, num_exponent_bits>::get; // How far left the exponent is shifted. static const uint32_t exponent_left_shift = num_fraction_bits; // How far from the right edge the fraction is shifted. static const uint32_t fraction_right_shift = static_cast<uint32_t>(sizeof(uint_type) * 8) - num_fraction_bits; // The maximum representable unbiased exponent. static const int_type max_exponent = (exponent_mask >> num_fraction_bits) - exponent_bias; // The minimum representable exponent for normalized numbers. static const int_type min_exponent = -static_cast<int_type>(exponent_bias); // Returns the bits associated with the value. uint_type getBits() const { … } // Returns the bits associated with the value, without the leading sign bit. uint_type getUnsignedBits() const { … } // Returns the bits associated with the exponent, shifted to start at the // lsb of the type. const uint_type getExponentBits() const { … } // Returns the exponent in unbiased form. This is the exponent in the // human-friendly form. const int_type getUnbiasedExponent() const { … } // Returns just the significand bits from the value. const uint_type getSignificandBits() const { … } // If the number was normalized, returns the unbiased exponent. // If the number was denormal, normalize the exponent first. const int_type getUnbiasedNormalizedExponent() const { … } // Returns the signficand after it has been normalized. const uint_type getNormalizedSignificand() const { … } // Returns true if this number represents a negative value. bool isNegative() const { … } // Sets this HexFloat from the individual components. // Note this assumes EVERY significand is normalized, and has an implicit // leading one. This means that the only way that this method will set 0, // is if you set a number so denormalized that it underflows. // Do not use this method with raw bits extracted from a subnormal number, // since subnormals do not have an implicit leading 1 in the significand. // The significand is also expected to be in the // lowest-most num_fraction_bits of the uint_type. // The exponent is expected to be unbiased, meaning an exponent of // 0 actually means 0. // If underflow_round_up is set, then on underflow, if a number is non-0 // and would underflow, we round up to the smallest denorm. void setFromSignUnbiasedExponentAndNormalizedSignificand( bool negative, int_type exponent, uint_type significand, bool round_denorm_up) { … } // Increments the significand of this number by the given amount. // If this would spill the significand into the implicit bit, // carry is set to true and the significand is shifted to fit into // the correct location, otherwise carry is set to false. // All significands and to_increment are assumed to be within the bounds // for a valid significand. static uint_type incrementSignificand(uint_type significand, uint_type to_increment, bool* carry) { … } // These exist because MSVC throws warnings on negative right-shifts // even if they are not going to be executed. Eg: // constant_number < 0? 0: constant_number // These convert the negative left-shifts into right shifts. template <typename int_type> uint_type negatable_left_shift(int_type N, uint_type val) { … } template <typename int_type> uint_type negatable_right_shift(int_type N, uint_type val) { … } // Returns the significand, rounded to fit in a significand in // other_T. This is shifted so that the most significant // bit of the rounded number lines up with the most significant bit // of the returned significand. template <typename other_T> typename other_T::uint_type getRoundedNormalizedSignificand( round_direction dir, bool* carry_bit) { … } // Casts this value to another HexFloat. If the cast is widening, // then round_dir is ignored. If the cast is narrowing, then // the result is rounded in the direction specified. // This number will retain Nan and Inf values. // It will also saturate to Inf if the number overflows, and // underflow to (0 or min depending on rounding) if the number underflows. template <typename other_T> void castTo(other_T& other, round_direction round_dir) { … } private: T value_; static_assert(num_used_bits == Traits::num_exponent_bits + Traits::num_fraction_bits + 1, "The number of bits do not fit"); static_assert(sizeof(T) == sizeof(uint_type), "The type sizes do not match"); }; // Returns 4 bits represented by the hex character. inline uint8_t get_nibble_from_character(int character) { … } // Outputs the given HexFloat to the stream. template <typename T, typename Traits> std::ostream& operator<<(std::ostream& os, const HexFloat<T, Traits>& value) { … } // Returns true if negate_value is true and the next character on the // input stream is a plus or minus sign. In that case we also set the fail bit // on the stream and set the value to the zero value for its type. template <typename T, typename Traits> inline bool RejectParseDueToLeadingSign(std::istream& is, bool negate_value, HexFloat<T, Traits>& value) { … } // Parses a floating point number from the given stream and stores it into the // value parameter. // If negate_value is true then the number may not have a leading minus or // plus, and if it successfully parses, then the number is negated before // being stored into the value parameter. // If the value cannot be correctly parsed or overflows the target floating // point type, then set the fail bit on the stream. // TODO(dneto): Promise C++11 standard behavior in how the value is set in // the error case, but only after all target platforms implement it correctly. // In particular, the Microsoft C++ runtime appears to be out of spec. template <typename T, typename Traits> inline std::istream& ParseNormalFloat(std::istream& is, bool negate_value, HexFloat<T, Traits>& value) { … } // Specialization of ParseNormalFloat for FloatProxy<Float16> values. // This will parse the float as it were a 32-bit floating point number, // and then round it down to fit into a Float16 value. // The number is rounded towards zero. // If negate_value is true then the number may not have a leading minus or // plus, and if it successfully parses, then the number is negated before // being stored into the value parameter. // If the value cannot be correctly parsed or overflows the target floating // point type, then set the fail bit on the stream. // TODO(dneto): Promise C++11 standard behavior in how the value is set in // the error case, but only after all target platforms implement it correctly. // In particular, the Microsoft C++ runtime appears to be out of spec. template <> inline std::istream& ParseNormalFloat<FloatProxy<Float16>, HexFloatTraits<FloatProxy<Float16>>>( std::istream& is, bool negate_value, HexFloat<FloatProxy<Float16>, HexFloatTraits<FloatProxy<Float16>>>& value) { … } // Reads a HexFloat from the given stream. // If the float is not encoded as a hex-float then it will be parsed // as a regular float. // This may fail if your stream does not support at least one unget. // Nan values can be encoded with "0x1.<not zero>p+exponent_bias". // This would normally overflow a float and round to // infinity but this special pattern is the exact representation for a NaN, // and therefore is actually encoded as the correct NaN. To encode inf, // either 0x0p+exponent_bias can be specified or any exponent greater than // exponent_bias. // Examples using IEEE 32-bit float encoding. // 0x1.0p+128 (+inf) // -0x1.0p-128 (-inf) // // 0x1.1p+128 (+Nan) // -0x1.1p+128 (-Nan) // // 0x1p+129 (+inf) // -0x1p+129 (-inf) template <typename T, typename Traits> std::istream& operator>>(std::istream& is, HexFloat<T, Traits>& value) { … } // Writes a FloatProxy value to a stream. // Zero and normal numbers are printed in the usual notation, but with // enough digits to fully reproduce the value. Other values (subnormal, // NaN, and infinity) are printed as a hex float. template <typename T> std::ostream& operator<<(std::ostream& os, const FloatProxy<T>& value) { … } template <> inline std::ostream& operator<<<Float16>(std::ostream& os, const FloatProxy<Float16>& value) { … } } #endif // LIBSPIRV_UTIL_HEX_FLOAT_H_
Codebase Browser
godot