Added element-wise arithmetic operators to series<T>.

tedmiddleton · Apr 28, 2023 · 19e45d3 · 19e45d3
1 parent 4a8e2b2
commit 19e45d3
Show file tree

Hide file tree

Showing 3 changed files with 786 additions and 0 deletions.
diff --git a/mainframe/impl/series.hpp b/mainframe/impl/series.hpp
@@ -491,6 +491,286 @@ series<T>::operator!=(const series<T>& other) const
     return m_name != other.m_name || *m_sharedvec != *(other.m_sharedvec);
 }
 
+template<typename T>
+template<typename U>
+void
+series<T>::operator+=(const U& value)
+{
+    unref();
+    for (T& t : *m_sharedvec) {
+        t += value;
+    }
+}
+
+template<typename T>
+template<typename U>
+void
+series<T>::operator-=(const U& value)
+{
+    unref();
+    for (T& t : *m_sharedvec) {
+        t -= value;
+    }
+}
+
+template<typename T>
+template<typename U>
+void
+series<T>::operator*=(const U& value)
+{
+    unref();
+    for (T& t : *m_sharedvec) {
+        t *= value;
+    }
+}
+
+template<typename T>
+template<typename U>
+void
+series<T>::operator/=(const U& value)
+{
+    unref();
+    for (T& t : *m_sharedvec) {
+        t /= value;
+    }
+}
+
+template<typename T>
+template<typename U>
+void
+series<T>::operator%=(const U& value)
+{
+    unref();
+    for (T& t : *m_sharedvec) {
+        t %= value;
+    }
+}
+
+template<typename T>
+template<typename U>
+void
+series<T>::operator+=(const series<U>& other)
+{
+    unref();
+    auto it1 = m_sharedvec->begin();
+    auto it2 = other.m_sharedvec->begin();
+    while (it1 != m_sharedvec->end() && it2 != other.m_sharedvec->end()) {
+        *it1 += *it2;
+        ++it1;
+        ++it2;
+    }
+}
+
+template<typename T>
+template<typename U>
+void
+series<T>::operator-=(const series<U>& other)
+{
+    unref();
+    auto it1 = m_sharedvec->begin();
+    auto it2 = other.m_sharedvec->begin();
+    while (it1 != m_sharedvec->end() && it2 != other.m_sharedvec->end()) {
+        *it1 -= *it2;
+        ++it1;
+        ++it2;
+    }
+}
+
+template<typename T>
+template<typename U>
+void
+series<T>::operator*=(const series<U>& other)
+{
+    unref();
+    auto it1 = m_sharedvec->begin();
+    auto it2 = other.m_sharedvec->begin();
+    while (it1 != m_sharedvec->end() && it2 != other.m_sharedvec->end()) {
+        *it1 *= *it2;
+        ++it1;
+        ++it2;
+    }
+}
+
+template<typename T>
+template<typename U>
+void
+series<T>::operator/=(const series<U>& other)
+{
+    unref();
+    auto it1 = m_sharedvec->begin();
+    auto it2 = other.m_sharedvec->begin();
+    while (it1 != m_sharedvec->end() && it2 != other.m_sharedvec->end()) {
+        *it1 /= *it2;
+        ++it1;
+        ++it2;
+    }
+}
+
+template<typename T>
+template<typename U>
+void
+series<T>::operator%=(const series<U>& other)
+{
+    unref();
+    auto it1 = m_sharedvec->begin();
+    auto it2 = other.m_sharedvec->begin();
+    while (it1 != m_sharedvec->end() && it2 != other.m_sharedvec->end()) {
+        *it1 %= *it2;
+        ++it1;
+        ++it2;
+    }
+}
+
+template<typename T>
+template<typename U>
+series<decltype(std::declval<T>() + std::declval<U>())>
+series<T>::operator+(const U& value) const
+{
+    using V = decltype(std::declval<T>() + std::declval<U>());
+    series<V> result;
+    for (const T& t : *m_sharedvec) {
+        result.m_sharedvec->push_back(t + value);
+    }
+    return result;
+}
+
+template<typename T>
+template<typename U>
+series<decltype(std::declval<T>() - std::declval<U>())>
+series<T>::operator-(const U& value) const
+{
+    using V = decltype(std::declval<T>() - std::declval<U>());
+    series<V> result;
+    for (const T& t : *m_sharedvec) {
+        result.m_sharedvec->push_back(t - value);
+    }
+    return result;
+}
+
+template<typename T>
+template<typename U>
+series<decltype(std::declval<T>() * std::declval<U>())>
+series<T>::operator*(const U& value) const
+{
+    using V = decltype(std::declval<T>() * std::declval<U>());
+    series<V> result;
+    for (const T& t : *m_sharedvec) {
+        result.m_sharedvec->push_back(t * value);
+    }
+    return result;
+}
+
+template<typename T>
+template<typename U>
+series<decltype(std::declval<T>() / std::declval<U>())>
+series<T>::operator/(const U& value) const
+{
+    using V = decltype(std::declval<T>() / std::declval<U>());
+    series<V> result;
+    for (const T& t : *m_sharedvec) {
+        result.m_sharedvec->push_back(t / value);
+    }
+    return result;
+}
+
+template<typename T>
+template<typename U>
+series<decltype(std::declval<T>() % std::declval<U>())>
+series<T>::operator%(const U& value) const
+{
+    using V = decltype(std::declval<T>() % std::declval<U>());
+    series<V> result;
+    for (const T& t : *m_sharedvec) {
+        result.m_sharedvec->push_back(t % value);
+    }
+    return result;
+}
+
+template<typename T>
+template<typename U>
+series<decltype(std::declval<T>() + std::declval<U>())>
+series<T>::operator+(const series<U>& other) const
+{
+    using V = decltype(std::declval<T>() + std::declval<U>());
+    series<V> result;
+    auto it1 = m_sharedvec->begin();
+    auto it2 = other.m_sharedvec->begin();
+    while (it1 != m_sharedvec->end() && it2 != other.m_sharedvec->end()) {
+        result.m_sharedvec->push_back(*it1 + *it2);
+        ++it1;
+        ++it2;
+    }
+    return result;
+}
+
+template<typename T>
+template<typename U>
+series<decltype(std::declval<T>() - std::declval<U>())>
+series<T>::operator-(const series<U>& other) const
+{
+    using V = decltype(std::declval<T>() - std::declval<U>());
+    series<V> result;
+    auto it1 = m_sharedvec->begin();
+    auto it2 = other.m_sharedvec->begin();
+    while (it1 != m_sharedvec->end() && it2 != other.m_sharedvec->end()) {
+        result.m_sharedvec->push_back(*it1 - *it2);
+        ++it1;
+        ++it2;
+    }
+    return result;
+}
+
+template<typename T>
+template<typename U>
+series<decltype(std::declval<T>() * std::declval<U>())>
+series<T>::operator*(const series<U>& other) const
+{
+    using V = decltype(std::declval<T>() * std::declval<U>());
+    series<V> result;
+    auto it1 = m_sharedvec->begin();
+    auto it2 = other.m_sharedvec->begin();
+    while (it1 != m_sharedvec->end() && it2 != other.m_sharedvec->end()) {
+        result.m_sharedvec->push_back(*it1 * *it2);
+        ++it1;
+        ++it2;
+    }
+    return result;
+}
+
+template<typename T>
+template<typename U>
+series<decltype(std::declval<T>() / std::declval<U>())>
+series<T>::operator/(const series<U>& other) const
+{
+    using V = decltype(std::declval<T>() / std::declval<U>());
+    series<V> result;
+    auto it1 = m_sharedvec->begin();
+    auto it2 = other.m_sharedvec->begin();
+    while (it1 != m_sharedvec->end() && it2 != other.m_sharedvec->end()) {
+        result.m_sharedvec->push_back(*it1 / *it2);
+        ++it1;
+        ++it2;
+    }
+    return result;
+}
+
+template<typename T>
+template<typename U>
+series<decltype(std::declval<T>() % std::declval<U>())>
+series<T>::operator%(const series<U>& other) const
+{
+    using V = decltype(std::declval<T>() % std::declval<U>());
+    series<V> result;
+    auto it1 = m_sharedvec->begin();
+    auto it2 = other.m_sharedvec->begin();
+    while (it1 != m_sharedvec->end() && it2 != other.m_sharedvec->end()) {
+        result.m_sharedvec->push_back(*it1 % *it2);
+        ++it1;
+        ++it2;
+    }
+    return result;
+} 
+
 template<typename T>
 void
 series<T>::push_back(const T& value)

diff --git a/mainframe/series.hpp b/mainframe/series.hpp
@@ -268,6 +268,86 @@ class series
     bool
     operator!=(const series<T>& other) const;
 
+    template<typename U>
+    void
+    operator+=(const U& value);
+
+    template<typename U>
+    void
+    operator-=(const U& value);
+
+    template<typename U>
+    void
+    operator*=(const U& value);
+
+    template<typename U>
+    void
+    operator/=(const U& value);
+
+    template<typename U>
+    void
+    operator%=(const U& value);
+
+    template<typename U>
+    void
+    operator+=(const series<U>& other);
+
+    template<typename U>
+    void
+    operator-=(const series<U>& other);
+
+    template<typename U>
+    void
+    operator*=(const series<U>& other);
+
+    template<typename U>
+    void
+    operator/=(const series<U>& other);
+
+    template<typename U>
+    void
+    operator%=(const series<U>& other);
+
+    template<typename U>
+    series<decltype(std::declval<T>() + std::declval<U>())>
+    operator+(const U& value) const;
+
+    template<typename U>
+    series<decltype(std::declval<T>() - std::declval<U>())>
+    operator-(const U& value) const;
+
+    template<typename U>
+    series<decltype(std::declval<T>() * std::declval<U>())>
+    operator*(const U& value) const;
+
+    template<typename U>
+    series<decltype(std::declval<T>() / std::declval<U>())>
+    operator/(const U& value) const;
+
+    template<typename U>
+    series<decltype(std::declval<T>() % std::declval<U>())>
+    operator%(const U& value) const;
+
+    template<typename U>
+    series<decltype(std::declval<T>() + std::declval<U>())>
+    operator+(const series<U>& other) const;
+
+    template<typename U>
+    series<decltype(std::declval<T>() - std::declval<U>())>
+    operator-(const series<U>& other) const;
+
+    template<typename U>
+    series<decltype(std::declval<T>() * std::declval<U>())>
+    operator*(const series<U>& other) const;
+
+    template<typename U>
+    series<decltype(std::declval<T>() / std::declval<U>())>
+    operator/(const series<U>& other) const;
+
+    template<typename U>
+    series<decltype(std::declval<T>() % std::declval<U>())>
+    operator%(const series<U>& other) const;
+
     // push_back, emplace_back, pop_back
     void
     push_back(const T& value);