ValueBundle.hpp

Go to the documentation of this file.

 
#pragma once
#include <cstring>
 
template <class T> struct ValueBundle
{
public:
    ValueBundle() : _data(nullptr), _size(0) {}
 
    ValueBundle(T *data, const int size) : _data(data), _size(size) {}
    
    ValueBundle &operator=(const ValueBundle<T> &rhs)
    {
        _size = rhs._size;
        _data = rhs._data;
        return *this;
    }
 
    T &operator[](const int n)
    {
        return _data[n];
    }
 
    int size() const
    {
        return _size;
    }
 
    T *data() const
    {
        return _data;
    }
 
    ValueBundle &multAdd(const T &rhs1, const ValueBundle<T> &rhs2)
    {
        for (int i = 0; i < _size; ++i) _data[i] += rhs1 * rhs2._data[i];
        return *this;
    }
 
    ValueBundle &multAdd(const ValueBundle<T> &rhs1, const T &rhs2)
    {
        return multAdd(rhs2, rhs1);
    }
 
    ValueBundle &multAdd(const ValueBundle<T> &rhs1, const ValueBundle<T> &rhs2)
    {
        for (int i = 0; i < _size; ++i) _data[i] += rhs1._data[i] * rhs2._data[i];
        return *this;
    }
 
    ValueBundle &multAdd(const T &rhs1, const ValueBundle<T> &rhs2, const ValueBundle<T> &rhs3)
    {
        for (int i = 0; i < _size; ++i) _data[i] += rhs1 * rhs2._data[i] * rhs3._data[i];
        return *this;
    }
 
    ValueBundle &multSub(const T &rhs1, const ValueBundle<T> &rhs2)
    {
        for (int i = 0; i < _size; ++i) _data[i] -= rhs1 * rhs2._data[i];
        return *this;
    }
 
    ValueBundle &multSub(const ValueBundle<T> &rhs1, const T &rhs2)
    {
        return multSub(rhs2, rhs1);
    }
 
    ValueBundle &multSub(const ValueBundle<T> &rhs1, const ValueBundle<T> &rhs2)
    {
        for (int i = 0; i < _size; ++i) _data[i] -= rhs1._data[i] * rhs2._data[i];
        return *this;
    }
 
    ValueBundle &multSub(const T &rhs1, const ValueBundle<T> &rhs2, const ValueBundle<T> &rhs3)
    {
        for (int i = 0; i < _size; ++i) _data[i] -= rhs1 * rhs2._data[i] * rhs3._data[i];
        return *this;
    }
 
    ValueBundle &operator+=(const ValueBundle &rhs)
    {
        for (int i = 0; i < _size; ++i) _data[i] += rhs._data[i];
        return *this;
    }
 
    ValueBundle &operator-=(const ValueBundle &rhs)
    {
        for (int i = 0; i < _size; ++i) _data[i] -= rhs._data[i];
        return *this;
    }
 
    ValueBundle &operator*=(const T &rhs)
    {
        for (int i = 0; i < _size; ++i) _data[i] *= rhs;
        return *this;
    }
 
    ValueBundle &operator/=(const T &rhs)
    {
        for (int i = 0; i < _size; ++i) _data[i] /= rhs;
        return *this;
    }
 
private:
    T *_data; 
    int _size; 
};
 
template <class T, int n> struct ValueSuperbundle
{
public:
    ValueSuperbundle(const int bundleSize) : hasOwnership(true)
    {
        for (int i = 0; i < n; ++i) bundles[i] = ValueBundle<T>(new T[bundleSize], bundleSize);
        reset();
    }
 
    ValueSuperbundle(const ValueSuperbundle &rhs) : hasOwnership(false)
    {
        for (int i = 0; i < n; ++i) bundles[i] = ValueBundle<T>(rhs.bundles[i].data(), rhs.bundles[i].size());
    }
 
    ~ValueSuperbundle()
    {
        if (hasOwnership)
        {
            for (int i = 0; i < n; ++i) delete[] bundles[i].data();
        }
    }
 
    ValueBundle<T> &bundle(const int m)
    {
        return bundles[m];
    }
 
    ValueSuperbundle &reset()
    {
        for (int i = 0; i < n; ++i) memset(bundles[i].data(), 0, bundles[i].size() * sizeof(T));
        return *this;
    }
 
    ValueSuperbundle &multAdd(const T &rhs1, const ValueSuperbundle<T, n> &rhs2)
    {
        for (int i = 0; i < n; ++i) bundles[i].multAdd(rhs1, rhs2.bundles[i]);
        return *this;
    }
 
    ValueSuperbundle &operator*=(const T &rhs)
    {
        for (int i = 0; i < n; ++i) bundles[i] *= rhs;
        return *this;
    }
 
    ValueSuperbundle &operator/=(const T &rhs)
    {
        for (int i = 0; i < n; ++i) bundles[i] /= rhs;
        return *this;
    }
 
    ValueSuperbundle &operator+=(const ValueSuperbundle<T, n> &rhs)
    {
        for (int i = 0; i < n; ++i) bundles[i] += rhs.bundles[i];
        return *this;
    }
 
private:
    ValueBundle<T> bundles[n]; 
    bool hasOwnership; 
};