MeLOn
Loading...
Searching...
No Matches
vectorarithmetics.h
Go to the documentation of this file.
1/**********************************************************************************
2* Copyright (c) 2020 Process Systems Engineering (AVT.SVT), RWTH Aachen University
3*
4* This program and the accompanying materials are made available under the
5* terms of the Eclipse Public License 2.0 which is available at
6* http://www.eclipse.org/legal/epl-2.0.
7*
8* SPDX-License-Identifier: EPL-2.0
9*
10* @file vectorarithmetics.h
11*
12* @brief File containing overloaded vector functions for performing linear algebra operations.
13*
14**********************************************************************************/
15
16#pragma once
17
18#include <vector> // std::vector
19#include <numeric> // std::inner_product
20#include <algorithm> // std::transform
21#include <cassert> // std::assert
22
23namespace melon {
33 template <typename T, typename U>
34 auto operator+(const std::vector<T> &v1, const std::vector<U> &v2) {
35 assert(v1.size() == v2.size());
36 std::vector<decltype(T(1) + U(1))> result;
37 result.reserve(v1.size());
38 std::transform(std::begin(v1), std::end(v1), std::begin(v2), std::back_inserter(result), [](T i, U j) { return i + j; });
39 return result;
40 };
41
51 template <typename T, typename U>
52 auto operator+(const std::vector<T> &v, const U s) {
53 std::vector<decltype(T(1) + U(1))> result;
54 result.reserve(v.size());
55 std::transform(std::begin(v), std::end(v), std::back_inserter(result), [s](T i) {return i + s; });
56 return result;
57 }
58
68 template <typename T, typename U>
69 auto operator-(std::vector<T> &v1, std::vector<U> &v2) {
70 assert(v1.size() == v2.size());
71 std::vector<decltype(v1.at(0) - v2.at(0))> result;
72 result.reserve(v1.size());
73 std::transform(std::begin(v1), std::end(v1), std::begin(v2), std::back_inserter(result), [](T i, U j) { return i - j; });
74 return result;
75 };
76
86 template <typename T, typename U>
87 auto operator-(const std::vector<T> &v, const U s) {
88 std::vector<decltype(T(1) - U(1))> result;
89 result.reserve(v.size());
90 std::transform(std::begin(v), std::end(v), std::back_inserter(result), [s](T i) {return i - s; });
91 return result;
92 }
93
103 template <typename T, typename U>
104 auto operator*(const T &s, const std::vector<U> &v) {
105 std::vector<decltype(T(1) * U(1))> result;
106 result.reserve(v.size());
107 std::transform(std::begin(v), std::end(v), std::back_inserter(result), [s](U i) {return i * s; });
108 return result;
109 }
110
120 template <typename T, typename U>
121 auto operator*(const std::vector<T> &v, const U &s) {
122 std::vector<decltype(T(1) * U(1))> result;
123 result.reserve(v.size());
124 std::transform(std::begin(v), std::end(v), std::back_inserter(result), [s](T i) {return i * s; });
125 return result;
126 }
127
137 template <typename T, typename U>
138 auto operator/(const std::vector<T>& v, const U& s) {
139 std::vector<decltype(T(1) / U(1))> result;
140 result.reserve(v.size());
141 std::transform(std::begin(v), std::end(v), std::back_inserter(result), [s](T i) {return i / s; });
142 return result;
143 }
144
154 template <typename T, typename U>
155 auto dot_product(const std::vector<T> &v1, const std::vector<U> &v2) {
156 assert(v1.size() == v2.size());
157
158 return std::inner_product(std::begin(v1), std::end(v1), std::begin(v2), T(0)*U(0));
159 }
160
170 template <typename T, typename U>
171 auto operator*(const std::vector<std::vector<T>> &m, const std::vector<U> &v) {
172 std::vector<decltype(T(1)*U(1))> result;
173 result.reserve(v.size());
174 std::transform(std::begin(m), std::end(m), std::back_inserter(result), [v](std::vector<T> m_i) {return dot_product(m_i, v); });
175
176 return result;
177 }
178
188 template <typename T, typename U>
189 auto operator*(const std::vector<std::vector<T>> &m1, const std::vector<std::vector<U>> &m2) {
190 assert(m1.at(0).size() == m2.size());
191 std::vector<std::vector<decltype(T(1) * U(1))>> result;
192 result.reserve(m1.size());
193 std::transform(std::begin(m2), std::end(m2), std::back_inserter(result), [m1](std::vector<U> m_i) {return m1 * m_i; });
194
195 return result;
196 }
197
205 template <typename T>
206 auto transpose(const std::vector<std::vector<T>> &m) {
207 std::vector<std::vector<T>> result(m.at(0).size(), std::vector<T>(m.size()));
208 for (std::vector<int>::size_type i = 0; i < m.size(); i++) {
209 for (size_t j = 0; j < m[0].size(); j++) {
210 result.at(j).at(i) = m.at(i).at(j);
211 }
212 }
213 return result;
214 }
215
223 template <typename T>
224 auto diag(const std::vector<std::vector<T>> &m) {
225 assert(m.size() == m.at(0).size());
226 std::vector<T> result;
227 for (size_t i = 0; i < m.size(); i++)
228 {
229 result.push_back(m.at(i).at(i));
230 }
231 return result;
232 }
233}
Definition kernel.h:21
auto operator*(const T &s, const std::vector< U > &v)
Overloaded operator for vector class allowing the calulation of a vector scalar product.
Definition vectorarithmetics.h:104
auto diag(const std::vector< std::vector< T > > &m)
Overloaded operator for vector class allowing to obtain a matrix diagonal.
Definition vectorarithmetics.h:224
auto operator/(const std::vector< T > &v, const U &s)
Overloaded operator for vector class allowing the calulation of a vector scalar division.
Definition vectorarithmetics.h:138
auto operator-(std::vector< T > &v1, std::vector< U > &v2)
Overloaded operator for vector class allowing substracting vectors.
Definition vectorarithmetics.h:69
auto operator+(const std::vector< T > &v1, const std::vector< U > &v2)
Overloaded operator for vector class allowing adding vectors.
Definition vectorarithmetics.h:34
auto dot_product(const std::vector< T > &v1, const std::vector< U > &v2)
Overloaded operator for vector class allowing the calulation of dot product of two vectors.
Definition vectorarithmetics.h:155
auto transpose(const std::vector< std::vector< T > > &m)
Overloaded operator for vector class allowing to transpose a matrix.
Definition vectorarithmetics.h:206