fixed dependencies

vendor/gonum.org/v1/gonum/num/quat/abs.go

@@ -0,0 +1,52 @@
+// Copyright ©2018 The Gonum Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Copyright 2017 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package quat
+
+import "math"
+
+// Abs returns the absolute value (also called the modulus) of q.
+func Abs(q Number) float64 {
+	// Special cases.
+	switch {
+	case IsInf(q):
+		return math.Inf(1)
+	case IsNaN(q):
+		return math.NaN()
+	}
+
+	r, i, j, k := q.Real, q.Imag, q.Jmag, q.Kmag
+	if r < 0 {
+		r = -r
+	}
+	if i < 0 {
+		i = -i
+	}
+	if j < 0 {
+		j = -j
+	}
+	if k < 0 {
+		k = -k
+	}
+	if r < i {
+		r, i = i, r
+	}
+	if r < j {
+		r, j = j, r
+	}
+	if r < k {
+		r, k = k, r
+	}
+	if r == 0 {
+		return 0
+	}
+	i /= r
+	j /= r
+	k /= r
+	return r * math.Sqrt(1+i*i+j*j+k*k)
+}

vendor/gonum.org/v1/gonum/num/quat/conj.go

@@ -0,0 +1,23 @@
+// Copyright ©2018 The Gonum Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Copyright 2017 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package quat
+
+// Conj returns the quaternion conjugate of q.
+func Conj(q Number) Number {
+	return Number{Real: q.Real, Imag: -q.Imag, Jmag: -q.Jmag, Kmag: -q.Kmag}
+}
+
+// Inv returns the quaternion inverse of q.
+func Inv(q Number) Number {
+	if IsInf(q) {
+		return zero
+	}
+	a := Abs(q)
+	return Scale(1/(a*a), Conj(q))
+}

vendor/gonum.org/v1/gonum/num/quat/doc.go

@@ -0,0 +1,10 @@
+// Copyright ©2018 The Gonum Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Package quat provides the quaternion numeric type and functions.
+//
+// For a good treatment of uses and behaviors of quaternions, see
+// the interactive videos by Ben Eater and Grant Sanderson here
+// https://eater.net/quaternions.
+package quat // imports "gonum.org/v1/gonum/num/quat"

vendor/gonum.org/v1/gonum/num/quat/exp.go

@@ -0,0 +1,84 @@
+// Copyright ©2018 The Gonum Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Copyright 2017 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package quat
+
+import "math"
+
+// Exp returns e**q, the base-e exponential of q.
+func Exp(q Number) Number {
+	w, uv := split(q)
+	if uv == zero {
+		return lift(math.Exp(w))
+	}
+	v := Abs(uv)
+	e := math.Exp(w)
+	s, c := math.Sincos(v)
+	return join(e*c, Scale(e*s/v, uv))
+}
+
+// Log returns the natural logarithm of q.
+func Log(q Number) Number {
+	w, uv := split(q)
+	if uv == zero {
+		return lift(math.Log(w))
+	}
+	v := Abs(uv)
+	return join(math.Log(Abs(q)), Scale(math.Atan2(v, w)/v, uv))
+}
+
+// Pow return q**r, the base-q exponential of r.
+// For generalized compatibility with math.Pow:
+//
+//	Pow(0, ±0) returns 1+0i+0j+0k
+//	Pow(0, c) for real(c)<0 returns Inf+0i+0j+0k if imag(c), jmag(c), kmag(c) are zero,
+//	    otherwise Inf+Inf i+Inf j+Inf k.
+func Pow(q, r Number) Number {
+	if q == zero {
+		w, uv := split(r)
+		switch {
+		case w == 0:
+			return Number{Real: 1}
+		case w < 0:
+			if uv == zero {
+				return Number{Real: math.Inf(1)}
+			}
+			return Inf()
+		case w > 0:
+			return zero
+		}
+	}
+	return Exp(Mul(Log(q), r))
+}
+
+// PowReal return q**r, the base-q exponential of r.
+// For generalized compatibility with math.Pow:
+//
+//	PowReal(0, ±0) returns 1+0i+0j+0k
+//	PowReal(0, c) for c<0 returns Inf+0i+0j+0k.
+func PowReal(q Number, r float64) Number {
+	if q == zero {
+		switch {
+		case r == 0:
+			return Number{Real: 1}
+		case r < 0:
+			return Inf()
+		case r > 0:
+			return zero
+		}
+	}
+	return Exp(Scale(r, Log(q)))
+}
+
+// Sqrt returns the square root of q.
+func Sqrt(q Number) Number {
+	if q == zero {
+		return zero
+	}
+	return PowReal(q, 0.5)
+}

vendor/gonum.org/v1/gonum/num/quat/inf.go

@@ -0,0 +1,22 @@
+// Copyright ©2018 The Gonum Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Copyright 2017 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package quat
+
+import "math"
+
+// IsInf returns true if any of real(q), imag(q), jmag(q), or kmag(q) is an infinity.
+func IsInf(q Number) bool {
+	return math.IsInf(q.Real, 0) || math.IsInf(q.Imag, 0) || math.IsInf(q.Jmag, 0) || math.IsInf(q.Kmag, 0)
+}
+
+// Inf returns a quaternion infinity, quaternion(+Inf, +Inf, +Inf, +Inf).
+func Inf() Number {
+	inf := math.Inf(1)
+	return Number{Real: inf, Imag: inf, Jmag: inf, Kmag: inf}
+}

vendor/gonum.org/v1/gonum/num/quat/nan.go

@@ -0,0 +1,26 @@
+// Copyright ©2018 The Gonum Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Copyright 2017 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package quat
+
+import "math"
+
+// IsNaN returns true if any of real(q), imag(q), jmag(q), or kmag(q) is NaN
+// and none are an infinity.
+func IsNaN(q Number) bool {
+	if math.IsInf(q.Real, 0) || math.IsInf(q.Imag, 0) || math.IsInf(q.Jmag, 0) || math.IsInf(q.Kmag, 0) {
+		return false
+	}
+	return math.IsNaN(q.Real) || math.IsNaN(q.Imag) || math.IsNaN(q.Jmag) || math.IsNaN(q.Kmag)
+}
+
+// NaN returns a quaternion “not-a-number” value.
+func NaN() Number {
+	nan := math.NaN()
+	return Number{Real: nan, Imag: nan, Jmag: nan, Kmag: nan}
+}

vendor/gonum.org/v1/gonum/num/quat/quat.go

@@ -0,0 +1,401 @@
+// Copyright ©2018 The Gonum Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package quat
+
+import (
+	"fmt"
+	"strconv"
+	"strings"
+)
+
+var zero Number
+
+// Number is a float64 precision quaternion.
+type Number struct {
+	Real, Imag, Jmag, Kmag float64
+}
+
+// Format implements fmt.Formatter.
+func (q Number) Format(fs fmt.State, c rune) {
+	prec, pOk := fs.Precision()
+	if !pOk {
+		prec = -1
+	}
+	width, wOk := fs.Width()
+	if !wOk {
+		width = -1
+	}
+	switch c {
+	case 'v':
+		if fs.Flag('#') {
+			fmt.Fprintf(fs, "%T{Real:%#v, Imag:%#v, Jmag:%#v, Kmag:%#v}", q, q.Real, q.Imag, q.Jmag, q.Kmag)
+			return
+		}
+		if fs.Flag('+') {
+			fmt.Fprintf(fs, "{Real:%+v, Imag:%+v, Jmag:%+v, Kmag:%+v}", q.Real, q.Imag, q.Jmag, q.Kmag)
+			return
+		}
+		c = 'g'
+		prec = -1
+		fallthrough
+	case 'e', 'E', 'f', 'F', 'g', 'G':
+		fre := fmtString(fs, c, prec, width, false)
+		fim := fmtString(fs, c, prec, width, true)
+		fmt.Fprintf(fs, fmt.Sprintf("(%s%[2]si%[2]sj%[2]sk)", fre, fim), q.Real, q.Imag, q.Jmag, q.Kmag)
+	default:
+		fmt.Fprintf(fs, "%%!%c(%T=%[2]v)", c, q)
+		return
+	}
+}
+
+// This is horrible, but it's what we have.
+func fmtString(fs fmt.State, c rune, prec, width int, wantPlus bool) string {
+	var b strings.Builder
+	b.WriteByte('%')
+	for _, f := range "0+- " {
+		if fs.Flag(int(f)) || (f == '+' && wantPlus) {
+			b.WriteByte(byte(f))
+		}
+	}
+	if width >= 0 {
+		fmt.Fprint(&b, width)
+	}
+	if prec >= 0 {
+		b.WriteByte('.')
+		if prec > 0 {
+			fmt.Fprint(&b, prec)
+		}
+	}
+	b.WriteRune(c)
+	return b.String()
+}
+
+// Add returns the sum of x and y.
+func Add(x, y Number) Number {
+	return Number{
+		Real: x.Real + y.Real,
+		Imag: x.Imag + y.Imag,
+		Jmag: x.Jmag + y.Jmag,
+		Kmag: x.Kmag + y.Kmag,
+	}
+}
+
+// Sub returns the difference of x and y, x-y.
+func Sub(x, y Number) Number {
+	return Number{
+		Real: x.Real - y.Real,
+		Imag: x.Imag - y.Imag,
+		Jmag: x.Jmag - y.Jmag,
+		Kmag: x.Kmag - y.Kmag,
+	}
+}
+
+// Mul returns the Hamiltonian product of x and y.
+func Mul(x, y Number) Number {
+	return Number{
+		Real: x.Real*y.Real - x.Imag*y.Imag - x.Jmag*y.Jmag - x.Kmag*y.Kmag,
+		Imag: x.Real*y.Imag + x.Imag*y.Real + x.Jmag*y.Kmag - x.Kmag*y.Jmag,
+		Jmag: x.Real*y.Jmag - x.Imag*y.Kmag + x.Jmag*y.Real + x.Kmag*y.Imag,
+		Kmag: x.Real*y.Kmag + x.Imag*y.Jmag - x.Jmag*y.Imag + x.Kmag*y.Real,
+	}
+}
+
+// Scale returns q scaled by f.
+func Scale(f float64, q Number) Number {
+	return Number{Real: f * q.Real, Imag: f * q.Imag, Jmag: f * q.Jmag, Kmag: f * q.Kmag}
+}
+
+// Parse converts the string s to a Number. The string may be parenthesized and
+// has the format [±]N±Ni±Nj±Nk. The order of the components is not strict.
+func Parse(s string) (Number, error) {
+	if len(s) == 0 {
+		return Number{}, parseError{state: -1}
+	}
+	orig := s
+
+	wantClose := s[0] == '('
+	if wantClose {
+		if s[len(s)-1] != ')' {
+			return Number{}, parseError{string: orig, state: -1}
+		}
+		s = s[1 : len(s)-1]
+	}
+	if len(s) == 0 {
+		return Number{}, parseError{string: orig, state: -1}
+	}
+	switch s[0] {
+	case 'n', 'N':
+		if strings.ToLower(s) == "nan" {
+			return NaN(), nil
+		}
+	case 'i', 'I':
+		if strings.ToLower(s) == "inf" {
+			return Inf(), nil
+		}
+	}
+
+	var q Number
+	var parts byte
+	for i := 0; i < 4; i++ {
+		beg, end, p, err := floatPart(s)
+		if err != nil {
+			return q, parseError{string: orig, state: -1}
+		}
+		if parts&(1<<p) != 0 {
+			return q, parseError{string: orig, state: -1}
+		}
+		parts |= 1 << p
+		var v float64
+		switch s[:end] {
+		case "-":
+			if len(s[end:]) == 0 {
+				return q, parseError{string: orig, state: -1}
+			}
+			v = -1
+		case "+":
+			if len(s[end:]) == 0 {
+				return q, parseError{string: orig, state: -1}
+			}
+			v = 1
+		default:
+			v, err = strconv.ParseFloat(s[beg:end], 64)
+			if err != nil {
+				return q, err
+			}
+		}
+		s = s[end:]
+		switch p {
+		case 0:
+			q.Real = v
+		case 1:
+			q.Imag = v
+			s = s[1:]
+		case 2:
+			q.Jmag = v
+			s = s[1:]
+		case 3:
+			q.Kmag = v
+			s = s[1:]
+		}
+		if len(s) == 0 {
+			return q, nil
+		}
+		if !isSign(rune(s[0])) {
+			return q, parseError{string: orig, state: -1}
+		}
+	}
+
+	return q, parseError{string: orig, state: -1}
+}
+
+func floatPart(s string) (beg, end int, part uint, err error) {
+	const (
+		wantMantSign = iota
+		wantMantIntInit
+		wantMantInt
+		wantMantFrac
+		wantExpSign
+		wantExpInt
+
+		wantInfN
+		wantInfF
+		wantCloseInf
+
+		wantNaNA
+		wantNaNN
+		wantCloseNaN
+	)
+	var i, state int
+	var r rune
+	for i, r = range s {
+		switch state {
+		case wantMantSign:
+			switch {
+			default:
+				return 0, i, 0, parseError{string: s, state: state, rune: r}
+			case isSign(r):
+				state = wantMantIntInit
+			case isDigit(r):
+				state = wantMantInt
+			case isDot(r):
+				state = wantMantFrac
+			case r == 'i', r == 'I':
+				state = wantInfN
+			case r == 'n', r == 'N':
+				state = wantNaNA
+			}
+
+		case wantMantIntInit:
+			switch {
+			default:
+				return 0, i, 0, parseError{string: s, state: state, rune: r}
+			case isDigit(r):
+				state = wantMantInt
+			case isDot(r):
+				state = wantMantFrac
+			case r == 'i':
+				// We need to sneak a look-ahead here.
+				if i == len(s)-1 || s[i+1] == '-' || s[i+1] == '+' {
+					return 0, i, 1, nil
+				}
+				fallthrough
+			case r == 'I':
+				state = wantInfN
+			case r == 'n', r == 'N':
+				state = wantNaNA
+			}
+
+		case wantMantInt:
+			switch {
+			default:
+				return 0, i, 0, parseError{string: s, state: state, rune: r}
+			case isDigit(r):
+				// Do nothing
+			case isDot(r):
+				state = wantMantFrac
+			case isExponent(r):
+				state = wantExpSign
+			case isSign(r):
+				return 0, i, 0, nil
+			case r == 'i':
+				return 0, i, 1, nil
+			case r == 'j':
+				return 0, i, 2, nil
+			case r == 'k':
+				return 0, i, 3, nil
+			}
+
+		case wantMantFrac:
+			switch {
+			default:
+				return 0, i, 0, parseError{string: s, state: state, rune: r}
+			case isDigit(r):
+				// Do nothing
+			case isExponent(r):
+				state = wantExpSign
+			case isSign(r):
+				return 0, i, 0, nil
+			case r == 'i':
+				return 0, i, 1, nil
+			case r == 'j':
+				return 0, i, 2, nil
+			case r == 'k':
+				return 0, i, 3, nil
+			}
+
+		case wantExpSign:
+			switch {
+			default:
+				return 0, i, 0, parseError{string: s, state: state, rune: r}
+			case isSign(r) || isDigit(r):
+				state = wantExpInt
+			}
+
+		case wantExpInt:
+			switch {
+			default:
+				return 0, i, 0, parseError{string: s, state: state, rune: r}
+			case isDigit(r):
+				// Do nothing
+			case isSign(r):
+				return 0, i, 0, nil
+			case r == 'i':
+				return 0, i, 1, nil
+			case r == 'j':
+				return 0, i, 2, nil
+			case r == 'k':
+				return 0, i, 3, nil
+			}
+
+		case wantInfN:
+			if r != 'n' && r != 'N' {
+				return 0, i, 0, parseError{string: s, state: state, rune: r}
+			}
+			state = wantInfF
+		case wantInfF:
+			if r != 'f' && r != 'F' {
+				return 0, i, 0, parseError{string: s, state: state, rune: r}
+			}
+			state = wantCloseInf
+		case wantCloseInf:
+			switch {
+			default:
+				return 0, i, 0, parseError{string: s, state: state, rune: r}
+			case isSign(r):
+				return 0, i, 0, nil
+			case r == 'i':
+				return 0, i, 1, nil
+			case r == 'j':
+				return 0, i, 2, nil
+			case r == 'k':
+				return 0, i, 3, nil
+			}
+
+		case wantNaNA:
+			if r != 'a' && r != 'A' {
+				return 0, i, 0, parseError{string: s, state: state, rune: r}
+			}
+			state = wantNaNN
+		case wantNaNN:
+			if r != 'n' && r != 'N' {
+				return 0, i, 0, parseError{string: s, state: state, rune: r}
+			}
+			state = wantCloseNaN
+		case wantCloseNaN:
+			if isSign(rune(s[0])) {
+				beg = 1
+			}
+			switch {
+			default:
+				return beg, i, 0, parseError{string: s, state: state, rune: r}
+			case isSign(r):
+				return beg, i, 0, nil
+			case r == 'i':
+				return beg, i, 1, nil
+			case r == 'j':
+				return beg, i, 2, nil
+			case r == 'k':
+				return beg, i, 3, nil
+			}
+		}
+	}
+	switch state {
+	case wantMantSign, wantExpSign, wantExpInt:
+		if state == wantExpInt && isDigit(r) {
+			break
+		}
+		return 0, i, 0, parseError{string: s, state: state, rune: r}
+	}
+	return 0, len(s), 0, nil
+}
+
+func isSign(r rune) bool {
+	return r == '+' || r == '-'
+}
+
+func isDigit(r rune) bool {
+	return '0' <= r && r <= '9'
+}
+
+func isExponent(r rune) bool {
+	return r == 'e' || r == 'E'
+}
+
+func isDot(r rune) bool {
+	return r == '.'
+}
+
+type parseError struct {
+	string string
+	state  int
+	rune   rune
+}
+
+func (e parseError) Error() string {
+	if e.state < 0 {
+		return fmt.Sprintf("quat: failed to parse: %q", e.string)
+	}
+	return fmt.Sprintf("quat: failed to parse in state %d with %q: %q", e.state, e.rune, e.string)
+}

vendor/gonum.org/v1/gonum/num/quat/trig.go

@@ -0,0 +1,171 @@
+// Copyright ©2018 The Gonum Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Copyright 2017 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package quat
+
+import "math"
+
+// Sin returns the sine of q.
+func Sin(q Number) Number {
+	w, uv := split(q)
+	if uv == zero {
+		return lift(math.Sin(w))
+	}
+	v := Abs(uv)
+	s, c := math.Sincos(w)
+	sh, ch := sinhcosh(v)
+	return join(s*ch, Scale(c*sh/v, uv))
+}
+
+// Sinh returns the hyperbolic sine of q.
+func Sinh(q Number) Number {
+	w, uv := split(q)
+	if uv == zero {
+		return lift(math.Sinh(w))
+	}
+	v := Abs(uv)
+	s, c := math.Sincos(v)
+	sh, ch := sinhcosh(w)
+	return join(c*sh, scale(s*ch/v, uv))
+}
+
+// Cos returns the cosine of q.
+func Cos(q Number) Number {
+	w, uv := split(q)
+	if uv == zero {
+		return lift(math.Cos(w))
+	}
+	v := Abs(uv)
+	s, c := math.Sincos(w)
+	sh, ch := sinhcosh(v)
+	return join(c*ch, Scale(-s*sh/v, uv))
+}
+
+// Cosh returns the hyperbolic cosine of q.
+func Cosh(q Number) Number {
+	w, uv := split(q)
+	if uv == zero {
+		return lift(math.Cosh(w))
+	}
+	v := Abs(uv)
+	s, c := math.Sincos(v)
+	sh, ch := sinhcosh(w)
+	return join(c*ch, scale(s*sh/v, uv))
+}
+
+// Tan returns the tangent of q.
+func Tan(q Number) Number {
+	d := Cos(q)
+	if d == zero {
+		return Inf()
+	}
+	return Mul(Sin(q), Inv(d))
+}
+
+// Tanh returns the hyperbolic tangent of q.
+func Tanh(q Number) Number {
+	if math.IsInf(q.Real, 1) {
+		r := Number{Real: 1}
+		// Change signs dependent on imaginary parts.
+		r.Imag *= math.Sin(2 * q.Imag)
+		r.Jmag *= math.Sin(2 * q.Jmag)
+		r.Kmag *= math.Sin(2 * q.Kmag)
+		return r
+	}
+	d := Cosh(q)
+	if d == zero {
+		return Inf()
+	}
+	return Mul(Sinh(q), Inv(d))
+}
+
+// Asin returns the inverse sine of q.
+func Asin(q Number) Number {
+	_, uv := split(q)
+	if uv == zero {
+		return lift(math.Asin(q.Real))
+	}
+	u := unit(uv)
+	return Mul(Scale(-1, u), Log(Add(Mul(u, q), Sqrt(Sub(Number{Real: 1}, Mul(q, q))))))
+}
+
+// Asinh returns the inverse hyperbolic sine of q.
+func Asinh(q Number) Number {
+	return Log(Add(q, Sqrt(Add(Number{Real: 1}, Mul(q, q)))))
+}
+
+// Acos returns the inverse cosine of q.
+func Acos(q Number) Number {
+	w, uv := split(Asin(q))
+	return join(math.Pi/2-w, Scale(-1, uv))
+}
+
+// Acosh returns the inverse hyperbolic cosine of q.
+func Acosh(q Number) Number {
+	w := Acos(q)
+	_, uv := split(w)
+	if uv == zero {
+		return w
+	}
+	w = Mul(w, unit(uv))
+	if w.Real < 0 {
+		w = Scale(-1, w)
+	}
+	return w
+}
+
+// Atan returns the inverse tangent of q.
+func Atan(q Number) Number {
+	w, uv := split(q)
+	if uv == zero {
+		return lift(math.Atan(w))
+	}
+	u := unit(uv)
+	return Mul(Mul(lift(0.5), u), Log(Mul(Add(u, q), Inv(Sub(u, q)))))
+}
+
+// Atanh returns the inverse hyperbolic tangent of q.
+func Atanh(q Number) Number {
+	w, uv := split(q)
+	if uv == zero {
+		return lift(math.Atanh(w))
+	}
+	u := unit(uv)
+	return Mul(Scale(-1, u), Atan(Mul(u, q)))
+}
+
+// calculate sinh and cosh
+func sinhcosh(x float64) (sh, ch float64) {
+	if math.Abs(x) <= 0.5 {
+		return math.Sinh(x), math.Cosh(x)
+	}
+	e := math.Exp(x)
+	ei := 0.5 / e
+	e *= 0.5
+	return e - ei, e + ei
+}
+
+// scale returns q scaled by f, except that inf×0 is 0.
+func scale(f float64, q Number) Number {
+	if f == 0 {
+		return Number{}
+	}
+	if q.Real != 0 {
+		q.Real *= f
+	}
+	if q.Imag != 0 {
+		q.Imag *= f
+	}
+	if q.Jmag != 0 {
+		q.Jmag *= f
+	}
+	if q.Kmag != 0 {
+		q.Kmag *= f
+	}
+	return q
+}

vendor/gonum.org/v1/gonum/num/quat/util.go

@@ -0,0 +1,26 @@
+// Copyright ©2018 The Gonum Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Copyright 2017 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package quat
+
+func lift(v float64) Number {
+	return Number{Real: v}
+}
+
+func split(q Number) (float64, Number) {
+	return q.Real, Number{Imag: q.Imag, Jmag: q.Jmag, Kmag: q.Kmag}
+}
+
+func join(w float64, uv Number) Number {
+	uv.Real = w
+	return uv
+}
+
+func unit(q Number) Number {
+	return Scale(1/Abs(q), q)
+}