From 7b4377ad9d8a7205416df8d6217ef2b010f89481 Mon Sep 17 00:00:00 2001 From: Taras Madan Date: Wed, 22 Jan 2025 16:07:17 +0100 Subject: vendor: delete --- vendor/github.com/x448/float16/.travis.yml | 13 -- vendor/github.com/x448/float16/LICENSE | 22 --- vendor/github.com/x448/float16/README.md | 133 ------------- vendor/github.com/x448/float16/float16.go | 302 ----------------------------- 4 files changed, 470 deletions(-) delete mode 100644 vendor/github.com/x448/float16/.travis.yml delete mode 100644 vendor/github.com/x448/float16/LICENSE delete mode 100644 vendor/github.com/x448/float16/README.md delete mode 100644 vendor/github.com/x448/float16/float16.go (limited to 'vendor/github.com/x448') diff --git a/vendor/github.com/x448/float16/.travis.yml b/vendor/github.com/x448/float16/.travis.yml deleted file mode 100644 index 8902bdaaf..000000000 --- a/vendor/github.com/x448/float16/.travis.yml +++ /dev/null @@ -1,13 +0,0 @@ -language: go - -go: - - 1.11.x - -env: - - GO111MODULE=on - -script: - - go test -short -coverprofile=coverage.txt -covermode=count ./... - -after_success: - - bash <(curl -s https://codecov.io/bash) diff --git a/vendor/github.com/x448/float16/LICENSE b/vendor/github.com/x448/float16/LICENSE deleted file mode 100644 index bf6e35785..000000000 --- a/vendor/github.com/x448/float16/LICENSE +++ /dev/null @@ -1,22 +0,0 @@ -MIT License - -Copyright (c) 2019 Montgomery Edwards⁴⁴⁸ and Faye Amacker - -Permission is hereby granted, free of charge, to any person obtaining a copy -of this software and associated documentation files (the "Software"), to deal -in the Software without restriction, including without limitation the rights -to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -copies of the Software, and to permit persons to whom the Software is -furnished to do so, subject to the following conditions: - -The above copyright notice and this permission notice shall be included in all -copies or substantial portions of the Software. - -THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE -SOFTWARE. - diff --git a/vendor/github.com/x448/float16/README.md b/vendor/github.com/x448/float16/README.md deleted file mode 100644 index b524b8135..000000000 --- a/vendor/github.com/x448/float16/README.md +++ /dev/null @@ -1,133 +0,0 @@ -# Float16 (Binary16) in Go/Golang -[![Build Status](https://travis-ci.org/x448/float16.svg?branch=master)](https://travis-ci.org/x448/float16) -[![codecov](https://codecov.io/gh/x448/float16/branch/master/graph/badge.svg?v=4)](https://codecov.io/gh/x448/float16) -[![Go Report Card](https://goreportcard.com/badge/github.com/x448/float16)](https://goreportcard.com/report/github.com/x448/float16) -[![Release](https://img.shields.io/github/release/x448/float16.svg?style=flat-square)](https://github.com/x448/float16/releases) -[![License](http://img.shields.io/badge/license-mit-blue.svg?style=flat-square)](https://raw.githubusercontent.com/x448/float16/master/LICENSE) - -`float16` package provides [IEEE 754 half-precision floating-point format (binary16)](https://en.wikipedia.org/wiki/Half-precision_floating-point_format) with IEEE 754 default rounding for conversions. IEEE 754-2008 refers to this 16-bit floating-point format as binary16. - -IEEE 754 default rounding ("Round-to-Nearest RoundTiesToEven") is considered the most accurate and statistically unbiased estimate of the true result. - -All possible 4+ billion floating-point conversions with this library are verified to be correct. - -Lowercase "float16" refers to IEEE 754 binary16. And capitalized "Float16" refers to exported Go data type provided by this library. - -## Features -Current features include: - -* float16 to float32 conversions use lossless conversion. -* float32 to float16 conversions use IEEE 754-2008 "Round-to-Nearest RoundTiesToEven". -* conversions using pure Go take about 2.65 ns/op on a desktop amd64. -* unit tests provide 100% code coverage and check all possible 4+ billion conversions. -* other functions include: IsInf(), IsNaN(), IsNormal(), PrecisionFromfloat32(), String(), etc. -* all functions in this library use zero allocs except String(). - -## Status -This library is used by [fxamacker/cbor](https://github.com/fxamacker/cbor) and is ready for production use on supported platforms. The version number < 1.0 indicates more functions and options are planned but not yet published. - -Current status: - -* core API is done and breaking API changes are unlikely. -* 100% of unit tests pass: - * short mode (`go test -short`) tests around 65765 conversions in 0.005s. - * normal mode (`go test`) tests all possible 4+ billion conversions in about 95s. -* 100% code coverage with both short mode and normal mode. -* tested on amd64 but it should work on all little-endian platforms supported by Go. - -Roadmap: - -* add functions for fast batch conversions leveraging SIMD when supported by hardware. -* speed up unit test when verifying all possible 4+ billion conversions. -* test on additional platforms. - -## Float16 to Float32 Conversion -Conversions from float16 to float32 are lossless conversions. All 65536 possible float16 to float32 conversions (in pure Go) are confirmed to be correct. - -Unit tests take a fraction of a second to check all 65536 expected values for float16 to float32 conversions. - -## Float32 to Float16 Conversion -Conversions from float32 to float16 use IEEE 754 default rounding ("Round-to-Nearest RoundTiesToEven"). All 4294967296 possible float32 to float16 conversions (in pure Go) are confirmed to be correct. - -Unit tests in normal mode take about 1-2 minutes to check all 4+ billion float32 input values and results for Fromfloat32(), FromNaN32ps(), and PrecisionFromfloat32(). - -Unit tests in short mode use a small subset (around 229 float32 inputs) and finish in under 0.01 second while still reaching 100% code coverage. - -## Usage -Install with `go get github.com/x448/float16`. -``` -// Convert float32 to float16 -pi := float32(math.Pi) -pi16 := float16.Fromfloat32(pi) - -// Convert float16 to float32 -pi32 := pi16.Float32() - -// PrecisionFromfloat32() is faster than the overhead of calling a function. -// This example only converts if there's no data loss and input is not a subnormal. -if float16.PrecisionFromfloat32(pi) == float16.PrecisionExact { - pi16 := float16.Fromfloat32(pi) -} -``` - -## Float16 Type and API -Float16 (capitalized) is a Go type with uint16 as the underlying state. There are 6 exported functions and 9 exported methods. -``` -package float16 // import "github.com/x448/float16" - -// Exported types and consts -type Float16 uint16 -const ErrInvalidNaNValue = float16Error("float16: invalid NaN value, expected IEEE 754 NaN") - -// Exported functions -Fromfloat32(f32 float32) Float16 // Float16 number converted from f32 using IEEE 754 default rounding - with identical results to AMD and Intel F16C hardware. NaN inputs - are converted with quiet bit always set on, to be like F16C. - -FromNaN32ps(nan float32) (Float16, error) // Float16 NaN without modifying quiet bit. - // The "ps" suffix means "preserve signaling". - // Returns sNaN and ErrInvalidNaNValue if nan isn't a NaN. - -Frombits(b16 uint16) Float16 // Float16 number corresponding to b16 (IEEE 754 binary16 rep.) -NaN() Float16 // Float16 of IEEE 754 binary16 not-a-number -Inf(sign int) Float16 // Float16 of IEEE 754 binary16 infinity according to sign - -PrecisionFromfloat32(f32 float32) Precision // quickly indicates exact, ..., overflow, underflow - // (inline and < 1 ns/op) -// Exported methods -(f Float16) Float32() float32 // float32 number converted from f16 using lossless conversion -(f Float16) Bits() uint16 // the IEEE 754 binary16 representation of f -(f Float16) IsNaN() bool // true if f is not-a-number (NaN) -(f Float16) IsQuietNaN() bool // true if f is a quiet not-a-number (NaN) -(f Float16) IsInf(sign int) bool // true if f is infinite based on sign (-1=NegInf, 0=any, 1=PosInf) -(f Float16) IsFinite() bool // true if f is not infinite or NaN -(f Float16) IsNormal() bool // true if f is not zero, infinite, subnormal, or NaN. -(f Float16) Signbit() bool // true if f is negative or negative zero -(f Float16) String() string // string representation of f to satisfy fmt.Stringer interface -``` -See [API](https://godoc.org/github.com/x448/float16) at godoc.org for more info. - -## Benchmarks -Conversions (in pure Go) are around 2.65 ns/op for float16 -> float32 and float32 -> float16 on amd64. Speeds can vary depending on input value. - -``` -All functions have zero allocations except float16.String(). - -FromFloat32pi-2 2.59ns ± 0% // speed using Fromfloat32() to convert a float32 of math.Pi to Float16 -ToFloat32pi-2 2.69ns ± 0% // speed using Float32() to convert a float16 of math.Pi to float32 -Frombits-2 0.29ns ± 5% // speed using Frombits() to cast a uint16 to Float16 - -PrecisionFromFloat32-2 0.29ns ± 1% // speed using PrecisionFromfloat32() to check for overflows, etc. -``` - -## System Requirements -* Tested on Go 1.11, 1.12, and 1.13 but it should also work with older versions. -* Tested on amd64 but it should also work on all little-endian platforms supported by Go. - -## Special Thanks -Special thanks to Kathryn Long (starkat99) for creating [half-rs](https://github.com/starkat99/half-rs), a very nice rust implementation of float16. - -## License -Copyright (c) 2019 Montgomery Edwards⁴⁴⁸ and Faye Amacker - -Licensed under [MIT License](LICENSE) diff --git a/vendor/github.com/x448/float16/float16.go b/vendor/github.com/x448/float16/float16.go deleted file mode 100644 index 1a0e6dad0..000000000 --- a/vendor/github.com/x448/float16/float16.go +++ /dev/null @@ -1,302 +0,0 @@ -// Copyright 2019 Montgomery Edwards⁴⁴⁸ and Faye Amacker -// -// Special thanks to Kathryn Long for her Rust implementation -// of float16 at github.com/starkat99/half-rs (MIT license) - -package float16 - -import ( - "math" - "strconv" -) - -// Float16 represents IEEE 754 half-precision floating-point numbers (binary16). -type Float16 uint16 - -// Precision indicates whether the conversion to Float16 is -// exact, subnormal without dropped bits, inexact, underflow, or overflow. -type Precision int - -const ( - - // PrecisionExact is for non-subnormals that don't drop bits during conversion. - // All of these can round-trip. Should always convert to float16. - PrecisionExact Precision = iota - - // PrecisionUnknown is for subnormals that don't drop bits during conversion but - // not all of these can round-trip so precision is unknown without more effort. - // Only 2046 of these can round-trip and the rest cannot round-trip. - PrecisionUnknown - - // PrecisionInexact is for dropped significand bits and cannot round-trip. - // Some of these are subnormals. Cannot round-trip float32->float16->float32. - PrecisionInexact - - // PrecisionUnderflow is for Underflows. Cannot round-trip float32->float16->float32. - PrecisionUnderflow - - // PrecisionOverflow is for Overflows. Cannot round-trip float32->float16->float32. - PrecisionOverflow -) - -// PrecisionFromfloat32 returns Precision without performing -// the conversion. Conversions from both Infinity and NaN -// values will always report PrecisionExact even if NaN payload -// or NaN-Quiet-Bit is lost. This function is kept simple to -// allow inlining and run < 0.5 ns/op, to serve as a fast filter. -func PrecisionFromfloat32(f32 float32) Precision { - u32 := math.Float32bits(f32) - - if u32 == 0 || u32 == 0x80000000 { - // +- zero will always be exact conversion - return PrecisionExact - } - - const COEFMASK uint32 = 0x7fffff // 23 least significant bits - const EXPSHIFT uint32 = 23 - const EXPBIAS uint32 = 127 - const EXPMASK uint32 = uint32(0xff) << EXPSHIFT - const DROPMASK uint32 = COEFMASK >> 10 - - exp := int32(((u32 & EXPMASK) >> EXPSHIFT) - EXPBIAS) - coef := u32 & COEFMASK - - if exp == 128 { - // +- infinity or NaN - // apps may want to do extra checks for NaN separately - return PrecisionExact - } - - // https://en.wikipedia.org/wiki/Half-precision_floating-point_format says, - // "Decimals between 2^−24 (minimum positive subnormal) and 2^−14 (maximum subnormal): fixed interval 2^−24" - if exp < -24 { - return PrecisionUnderflow - } - if exp > 15 { - return PrecisionOverflow - } - if (coef & DROPMASK) != uint32(0) { - // these include subnormals and non-subnormals that dropped bits - return PrecisionInexact - } - - if exp < -14 { - // Subnormals. Caller may want to test these further. - // There are 2046 subnormals that can successfully round-trip f32->f16->f32 - // and 20 of those 2046 have 32-bit input coef == 0. - // RFC 7049 and 7049bis Draft 12 don't precisely define "preserves value" - // so some protocols and libraries will choose to handle subnormals differently - // when deciding to encode them to CBOR float32 vs float16. - return PrecisionUnknown - } - - return PrecisionExact -} - -// Frombits returns the float16 number corresponding to the IEEE 754 binary16 -// representation u16, with the sign bit of u16 and the result in the same bit -// position. Frombits(Bits(x)) == x. -func Frombits(u16 uint16) Float16 { - return Float16(u16) -} - -// Fromfloat32 returns a Float16 value converted from f32. Conversion uses -// IEEE default rounding (nearest int, with ties to even). -func Fromfloat32(f32 float32) Float16 { - return Float16(f32bitsToF16bits(math.Float32bits(f32))) -} - -// ErrInvalidNaNValue indicates a NaN was not received. -const ErrInvalidNaNValue = float16Error("float16: invalid NaN value, expected IEEE 754 NaN") - -type float16Error string - -func (e float16Error) Error() string { return string(e) } - -// FromNaN32ps converts nan to IEEE binary16 NaN while preserving both -// signaling and payload. Unlike Fromfloat32(), which can only return -// qNaN because it sets quiet bit = 1, this can return both sNaN and qNaN. -// If the result is infinity (sNaN with empty payload), then the -// lowest bit of payload is set to make the result a NaN. -// Returns ErrInvalidNaNValue and 0x7c01 (sNaN) if nan isn't IEEE 754 NaN. -// This function was kept simple to be able to inline. -func FromNaN32ps(nan float32) (Float16, error) { - const SNAN = Float16(uint16(0x7c01)) // signalling NaN - - u32 := math.Float32bits(nan) - sign := u32 & 0x80000000 - exp := u32 & 0x7f800000 - coef := u32 & 0x007fffff - - if (exp != 0x7f800000) || (coef == 0) { - return SNAN, ErrInvalidNaNValue - } - - u16 := uint16((sign >> 16) | uint32(0x7c00) | (coef >> 13)) - - if (u16 & 0x03ff) == 0 { - // result became infinity, make it NaN by setting lowest bit in payload - u16 = u16 | 0x0001 - } - - return Float16(u16), nil -} - -// NaN returns a Float16 of IEEE 754 binary16 not-a-number (NaN). -// Returned NaN value 0x7e01 has all exponent bits = 1 with the -// first and last bits = 1 in the significand. This is consistent -// with Go's 64-bit math.NaN(). Canonical CBOR in RFC 7049 uses 0x7e00. -func NaN() Float16 { - return Float16(0x7e01) -} - -// Inf returns a Float16 with an infinity value with the specified sign. -// A sign >= returns positive infinity. -// A sign < 0 returns negative infinity. -func Inf(sign int) Float16 { - if sign >= 0 { - return Float16(0x7c00) - } - return Float16(0x8000 | 0x7c00) -} - -// Float32 returns a float32 converted from f (Float16). -// This is a lossless conversion. -func (f Float16) Float32() float32 { - u32 := f16bitsToF32bits(uint16(f)) - return math.Float32frombits(u32) -} - -// Bits returns the IEEE 754 binary16 representation of f, with the sign bit -// of f and the result in the same bit position. Bits(Frombits(x)) == x. -func (f Float16) Bits() uint16 { - return uint16(f) -} - -// IsNaN reports whether f is an IEEE 754 binary16 “not-a-number” value. -func (f Float16) IsNaN() bool { - return (f&0x7c00 == 0x7c00) && (f&0x03ff != 0) -} - -// IsQuietNaN reports whether f is a quiet (non-signaling) IEEE 754 binary16 -// “not-a-number” value. -func (f Float16) IsQuietNaN() bool { - return (f&0x7c00 == 0x7c00) && (f&0x03ff != 0) && (f&0x0200 != 0) -} - -// IsInf reports whether f is an infinity (inf). -// A sign > 0 reports whether f is positive inf. -// A sign < 0 reports whether f is negative inf. -// A sign == 0 reports whether f is either inf. -func (f Float16) IsInf(sign int) bool { - return ((f == 0x7c00) && sign >= 0) || - (f == 0xfc00 && sign <= 0) -} - -// IsFinite returns true if f is neither infinite nor NaN. -func (f Float16) IsFinite() bool { - return (uint16(f) & uint16(0x7c00)) != uint16(0x7c00) -} - -// IsNormal returns true if f is neither zero, infinite, subnormal, or NaN. -func (f Float16) IsNormal() bool { - exp := uint16(f) & uint16(0x7c00) - return (exp != uint16(0x7c00)) && (exp != 0) -} - -// Signbit reports whether f is negative or negative zero. -func (f Float16) Signbit() bool { - return (uint16(f) & uint16(0x8000)) != 0 -} - -// String satisfies the fmt.Stringer interface. -func (f Float16) String() string { - return strconv.FormatFloat(float64(f.Float32()), 'f', -1, 32) -} - -// f16bitsToF32bits returns uint32 (float32 bits) converted from specified uint16. -func f16bitsToF32bits(in uint16) uint32 { - // All 65536 conversions with this were confirmed to be correct - // by Montgomery Edwards⁴⁴⁸ (github.com/x448). - - sign := uint32(in&0x8000) << 16 // sign for 32-bit - exp := uint32(in&0x7c00) >> 10 // exponenent for 16-bit - coef := uint32(in&0x03ff) << 13 // significand for 32-bit - - if exp == 0x1f { - if coef == 0 { - // infinity - return sign | 0x7f800000 | coef - } - // NaN - return sign | 0x7fc00000 | coef - } - - if exp == 0 { - if coef == 0 { - // zero - return sign - } - - // normalize subnormal numbers - exp++ - for coef&0x7f800000 == 0 { - coef <<= 1 - exp-- - } - coef &= 0x007fffff - } - - return sign | ((exp + (0x7f - 0xf)) << 23) | coef -} - -// f32bitsToF16bits returns uint16 (Float16 bits) converted from the specified float32. -// Conversion rounds to nearest integer with ties to even. -func f32bitsToF16bits(u32 uint32) uint16 { - // Translated from Rust to Go by Montgomery Edwards⁴⁴⁸ (github.com/x448). - // All 4294967296 conversions with this were confirmed to be correct by x448. - // Original Rust implementation is by Kathryn Long (github.com/starkat99) with MIT license. - - sign := u32 & 0x80000000 - exp := u32 & 0x7f800000 - coef := u32 & 0x007fffff - - if exp == 0x7f800000 { - // NaN or Infinity - nanBit := uint32(0) - if coef != 0 { - nanBit = uint32(0x0200) - } - return uint16((sign >> 16) | uint32(0x7c00) | nanBit | (coef >> 13)) - } - - halfSign := sign >> 16 - - unbiasedExp := int32(exp>>23) - 127 - halfExp := unbiasedExp + 15 - - if halfExp >= 0x1f { - return uint16(halfSign | uint32(0x7c00)) - } - - if halfExp <= 0 { - if 14-halfExp > 24 { - return uint16(halfSign) - } - coef := coef | uint32(0x00800000) - halfCoef := coef >> uint32(14-halfExp) - roundBit := uint32(1) << uint32(13-halfExp) - if (coef&roundBit) != 0 && (coef&(3*roundBit-1)) != 0 { - halfCoef++ - } - return uint16(halfSign | halfCoef) - } - - uHalfExp := uint32(halfExp) << 10 - halfCoef := coef >> 13 - roundBit := uint32(0x00001000) - if (coef&roundBit) != 0 && (coef&(3*roundBit-1)) != 0 { - return uint16((halfSign | uHalfExp | halfCoef) + 1) - } - return uint16(halfSign | uHalfExp | halfCoef) -} -- cgit mrf-deployment