LLL/vector.h at master · or17191/LLL · GitHub

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
107
108
109
110
111
112
113
114
115
116
117
#include <vector>
#include <iostream>
#define vectort std::vector<T>
template <class T>
class Vector
{
	private:
		vectort entries;
	public:
		Vector<T>()
		{
			entries = vectort(1, 0);
		}

		Vector<T>(int size): entries(size, 0){}

		Vector<T>(const vectort& v)
		{
			entries = v;
		}

		Vector<T>(const Vector& v)
		{
			entries = v.entries;
		}

		int dimension() const
		{
			return entries.size();
		}

		T operator()(int  i) const
		{
			return entries[i];
		}
		T& operator()(int  i)
		{
			return entries[i];
		}

		template <class U>
		friend Vector<U> operator*(const Vector<U>& v, U scalar);

		template <class U>
		friend Vector<U> operator*(U scalar, const Vector<U>& v);

		T operator*(const Vector<T>& other) const
		{
			T res = 0;
			for (int i = 0; i < dimension(); i++)
				res += entries[i] * other(i);

			return res;
		}

		Vector<T> operator+(const Vector& other) const
		{
			vectort new_entries = entries;
			for (int i = 0; i < dimension(); i++)
				new_entries[i] += other(i);

			return new_entries;
		}

		Vector<T> operator-() const
		{
			vectort new_entries = entries;
			for (int i = 0; i < dimension(); i++)
				new_entries[i] = - new_entries[i];

			return new_entries;
		}

		Vector<T> operator-(const Vector& other) const
		{
			vectort new_entries = entries;
			for (int i = 0; i < dimension(); i++)
				new_entries[i] -= other(i);

			return new_entries;
		}


};

template <class T>
Vector<T> operator*(const Vector<T>& v, T scalar)
{
	vectort entries = v.entries;
	for (int i = 0; i < v.dimension(); i++)
		entries[i] *= scalar;

	return entries;
}

template <class T>
Vector<T> operator*(T scalar, const Vector<T>& v)
{
	vectort entries = v.entries;
	for (int i = 0; i < v.dimension(); i++)
		entries[i] *= scalar;

	return entries;
}

template <class T>
std::ostream& operator<<(std::ostream& strm, const Vector<T>& v)
{
	strm << "(";
	for (int i = 0; i < v.dimension()-1; i++)
	{
		strm << v(i) << ", ";
	}
	strm << v(v.dimension()-1) << ")\n";

	return strm;
}