func Max(a, b *T) T {
	max := *a
	if b[0] > max[0] {
		max[0] = b[0]
	}
	if b[1] > max[1] {
		max[1] = b[1]
	}
	return max
}
Max returns the component wise maximum of two vectors.
package vec2
import (
	"fmt"
	math "github.com/ungerik/go3d/fmath"
	"github.com/ungerik/go3d/generic"
)
var (
	Zero = T{}
	UnitX = T{1, 0}
	UnitY = T{0, 1}
	UnitXY = T{1, 1}
	MinVal = T{-math.MaxFloat32, -math.MaxFloat32}
	MaxVal = T{+math.MaxFloat32, +math.MaxFloat32}
)
type T [2]float32
func From(other generic.T) T {
	return T{other.Get(0, 0), other.Get(0, 1)}
}
func Parse(s string) (r T, err error) {
	_, err = fmt.Sscan(s, &r[0], &r[1])
	return r, err
}
func (vec *T) String() string {
	return fmt.Sprint(vec[0], vec[1])
}
func (vec *T) Rows() int {
	return 2
}
func (vec *T) Cols() int {
	return 1
}
func (vec *T) Size() int {
	return 2
}
func (vec *T) Slice() []float32 {
	return vec[:]
}
func (vec *T) Get(col, row int) float32 {
	return vec[row]
}
func (vec *T) IsZero() bool {
	return vec[0] == 0 && vec[1] == 0
}
func (vec *T) Length() float32 {
	return float32(math.Hypot(vec[0], vec[1]))
}
func (vec *T) LengthSqr() float32 {
	return vec[0]*vec[0] + vec[1]*vec[1]
}
func (vec *T) Scale(f float32) *T {
	vec[0] *= f
	vec[1] *= f
	return vec
}
func (vec *T) Scaled(f float32) T {
	return T{vec[0] * f, vec[1] * f}
}
func (vec *T) Invert() *T {
	vec[0] = -vec[0]
	vec[1] = -vec[1]
	return vec
}
func (vec *T) Inverted() T {
	return T{-vec[0], -vec[1]}
}
func (vec *T) Normalize() *T {
	sl := vec.LengthSqr()
	if sl == 0 || sl == 1 {
		return vec
	}
	return vec.Scale(1 / math.Sqrt(sl))
}
func (vec *T) Normalized() T {
	v := *vec
	v.Normalize()
	return v
}
func (vec *T) Add(v *T) *T {
	vec[0] += v[0]
	vec[1] += v[1]
	return vec
}
func (vec *T) Sub(v *T) *T {
	vec[0] -= v[0]
	vec[1] -= v[1]
	return vec
}
func (vec *T) Mul(v *T) *T {
	vec[0] *= v[0]
	vec[1] *= v[1]
	return vec
}
func (vec *T) Rotate(angle float32) *T {
	*vec = vec.Rotated(angle)
	return vec
}
func (vec *T) Rotated(angle float32) T {
	sinus := math.Sin(angle)
	cosinus := math.Cos(angle)
	return T{
		vec[0]*cosinus - vec[1]*sinus,
		vec[0]*sinus + vec[1]*cosinus,
	}
}
func (vec *T) RotateAroundPoint(point *T, angle float32) *T {
	return vec.Sub(point).Rotate(angle).Add(point)
}
func (vec *T) Rotate90DegLeft() *T {
	temp := vec[0]
	vec[0] = -vec[1]
	vec[1] = temp
	return vec
}
func (vec *T) Rotate90DegRight() *T {
	temp := vec[0]
	vec[0] = vec[1]
	vec[1] = -temp
	return vec
}
func (vec *T) Angle() float32 {
	return math.Atan2(vec[1], vec[0])
}
func Add(a, b *T) T {
	return T{a[0] + b[0], a[1] + b[1]}
}
func Sub(a, b *T) T {
	return T{a[0] - b[0], a[1] - b[1]}
}
func Mul(a, b *T) T {
	return T{a[0] * b[0], a[1] * b[1]}
}
func Dot(a, b *T) float32 {
	return a[0]*b[0] + a[1]*b[1]
}
func Cross(a, b *T) T {
	return T{
		a[1]*b[0] - a[0]*b[1],
		a[0]*b[1] - a[1]*b[0],
	}
}
func Angle(a, b *T) float32 {
	v := Dot(a, b) / (a.Length() * b.Length())
	if v > 1. {
		v = v - 2
	} else if v < -1. {
		v = v + 2
	}
	return math.Acos(v)
}
func IsLeftWinding(a, b *T) bool {
	ab := b.Rotated(-a.Angle())
	return ab.Angle() > 0
}
func IsRightWinding(a, b *T) bool {
	ab := b.Rotated(-a.Angle())
	return ab.Angle() < 0
}
func Min(a, b *T) T {
	min := *a
	if b[0] < min[0] {
		min[0] = b[0]
	}
	if b[1] < min[1] {
		min[1] = b[1]
	}
	return min
}