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
|
/*
* Triplet.hh
*
* Template implementation of the Triplet abstract data type.
* The class also provides basic three-dimensional vector operations.
*/
#include <array>
#include <cstddef>
#include <algorithm>
/**
* A generic three-element tuple.
*
* In this experiment, Triplet is also treated as a three-dimensional
* vector, supporting vector addition, subtraction, scalar multiplication
* and dot product.
*
* T is the element type of the triplet.
*/
template<typename T>
class Triplet {
public:
Triplet (T a, T b, T c) : data_{a, b, c} {}
T &operator[] (std::size_t i) {
return data_[i];
}
const T &operator[] (std::size_t i) const
{
return data_[i];
}
Triplet operator+ (const Triplet &rhs) const
{
return Triplet (data_[0] + rhs.data_[0],
data_[1] + rhs.data_[1],
data_[2] + rhs.data_[2]);
}
Triplet operator- (const Triplet &rhs) const
{
return Triplet (data_[0] - rhs.data_[0],
data_[1] - rhs.data_[1],
data_[2] - rhs.data_[2]);
}
/* Scalar multiplication: vector * scalar. */
Triplet operator* (const T& scalar) const
{
return Triplet(
data_[0] * scalar,
data_[1] * scalar,
data_[2] * scalar);
}
/* Scalar multiplication: scalar * vector. */
friend Triplet
operator* (const T &scalar, const Triplet &v) {
return v * scalar;
}
/* Dot product of two three-dimensional vectors. */
T operator* (const Triplet &rhs) const {
return data_[0] * rhs.data_[0]
+ data_[1] * rhs.data_[1]
+ data_[2] * rhs.data_[2];
}
T max () const {
return *std::max_element (data_.begin (), data_.end ());
}
T min() const {
return *std::min_element( data_.begin (), data_.end ());
}
/* Return true if the elements are in nondecreasing order. */
bool is_ascending() const {
return data_[0] <= data_[1] && data_[1] <= data_[2];
}
/* Return true if the elements are in nonincreasing order. */
bool is_descending() const {
return data_[0] >= data_[1] && data_[1] >= data_[2];
}
private:
std::array<T, 3> data_;
};
|
