vendor: delete

4 files changed, 0 insertions, 470 deletions

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)
-}