MeLOn
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 
23 namespace 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 }
melon::diag
auto diag(const std::vector< std::vector< T >> &m)
Overloaded operator for vector class allowing to obtain a matrix diagonal.
Definition: vectorarithmetics.h:237
melon::dot_product
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:168
melon::operator*
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:117
melon::operator+
auto operator+(const std::vector< T > &v1, const std::vector< U > &v2)
Overloaded operator for vector class allowing adding vectors.
Definition: vectorarithmetics.h:47
melon::transpose
auto transpose(const std::vector< std::vector< T >> &m)
Overloaded operator for vector class allowing to transpose a matrix.
Definition: vectorarithmetics.h:219
melon::operator/
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:151
melon
Definition: kernel.h:21
melon::operator-
auto operator-(std::vector< T > &v1, std::vector< U > &v2)
Overloaded operator for vector class allowing substracting vectors.
Definition: vectorarithmetics.h:82