1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106

// Copyright 2020 Yevhenii Reizner
//
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#[cfg(all(not(feature = "std"), feature = "no-std-float"))]
use crate::NoStdFloat;

// Right now, there are no visible benefits of using SIMD for f32x2. So we don't.
/// A pair of f32 numbers.
///
/// Mainly for internal use. Do not rely on it!
#[allow(non_camel_case_types)]
#[derive(Copy, Clone, Default, PartialEq, Debug)]
pub struct f32x2(pub [f32; 2]);

impl f32x2 {
    /// Creates a new pair.
    pub fn new(a: f32, b: f32) -> f32x2 {
        f32x2([a, b])
    }

    /// Creates a new pair from a single value.
    pub fn splat(x: f32) -> f32x2 {
        f32x2([x, x])
    }

    /// Returns an absolute value.
    pub fn abs(self) -> f32x2 {
        f32x2([
            self.x().abs(),
            self.y().abs(),
        ])
    }

    /// Returns a minimum value.
    pub fn min(self, other: f32x2) -> f32x2 {
        f32x2([
            self.x().min(other.x()),
            self.y().min(other.y()),
        ])
    }

    /// Returns a maximum value.
    pub fn max(self, other: f32x2) -> f32x2 {
        f32x2([
            self.x().max(other.x()),
            self.y().max(other.y()),
        ])
    }

    /// Returns a maximum of both values.
    pub fn max_component(self) -> f32 {
        self.x().max(self.y())
    }

    /// Returns the first value.
    pub fn x(&self) -> f32 { self.0[0] }

    /// Returns the second value.
    pub fn y(&self) -> f32 { self.0[1] }
}

impl core::ops::Add<f32x2> for f32x2 {
    type Output = f32x2;

    fn add(self, other: f32x2) -> f32x2 {
        f32x2([
            self.x() + other.x(),
            self.y() + other.y(),
        ])
    }
}

impl core::ops::Sub<f32x2> for f32x2 {
    type Output = f32x2;

    fn sub(self, other: f32x2) -> f32x2 {
        f32x2([
            self.x() - other.x(),
            self.y() - other.y(),
        ])
    }
}

impl core::ops::Mul<f32x2> for f32x2 {
    type Output = f32x2;

    fn mul(self, other: f32x2) -> f32x2 {
        f32x2([
            self.x() * other.x(),
            self.y() * other.y(),
        ])
    }
}

impl core::ops::Div<f32x2> for f32x2 {
    type Output = f32x2;

    fn div(self, other: f32x2) -> f32x2 {
        f32x2([
            self.x() / other.x(),
            self.y() / other.y(),
        ])
    }
}