AbstractProperty.h

/* Copyright 2017 Kristofer Björnson
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
 
#ifndef COM_DAFER45_TBTK_ABSTRACT_PROPERTY
#define COM_DAFER45_TBTK_ABSTRACT_PROPERTY
 
#include "TBTK/Model.h"
#include "TBTK/Property/Property.h"
#include "TBTK/Property/IndexDescriptor.h"
#include "TBTK/SparseMatrix.h"
#include "TBTK/SpinMatrix.h"
#include "TBTK/TBTKMacros.h"
 
#include "TBTK/json.hpp"
 
namespace TBTK{
namespace Property{
 
template<typename DataType>
class AbstractProperty : public Property, public Serializable, public Streamable{
public:
    unsigned int getBlockSize() const;
 
    unsigned int getSize() const;
 
    const std::vector<DataType>& getData() const;
 
    std::vector<DataType>& getDataRW();
 
    unsigned int getDimensions() const;
 
    std::vector<int> getRanges() const;
 
    int getOffset(const Index &index) const;
 
    const IndexDescriptor& getIndexDescriptor() const;
 
    bool contains(const Index &index) const;
 
    void reduce(
        const std::vector<Index> &targetPatterns,
        const std::vector<Index> &newPatterns
    );
 
    void hermitianConjugate();
 
    std::vector<SparseMatrix<DataType>> toSparseMatrices(
        const Model &model
    ) const;
 
    virtual const DataType& operator()(
        const Index &index,
        unsigned int offset = 0
    ) const;
 
    virtual DataType& operator()(
        const Index &index,
        unsigned int offset = 0
    );
 
    DataType& operator()(const std::initializer_list<Subindex> &index);
 
    const DataType& operator()(
        const std::initializer_list<Subindex> &index
    ) const;
 
//  DataType& operator()(const std::initializer_list<unsigned int> &index);
 
/*  const DataType& operator()(
        const std::initializer_list<unsigned int> &index
    ) const;*/
 
    virtual const DataType& operator()(unsigned int offset) const;
 
    virtual DataType& operator()(unsigned int offset);
 
    void setAllowIndexOutOfBoundsAccess(bool allowIndexOutOfBoundsAccess);
 
    void setDefaultValue(const DataType &defaultValue);
 
    void replaceValues(
        const DataType &targetValue,
        const DataType &replacementValue
    );
 
    virtual std::string toString() const;
 
    virtual std::string serialize(Mode mode) const;
protected:
    AbstractProperty();
 
    AbstractProperty(unsigned int blockSize);
 
    AbstractProperty(
        unsigned int blockSize,
        const DataType *data
    );
 
    AbstractProperty(
        const std::vector<int> &ranges,
        unsigned int blockSize
    );
 
    AbstractProperty(
        const std::vector<int> &ranges,
        unsigned int blockSize,
        const DataType *data
    );
 
    AbstractProperty(
        const IndexTree &indexTree,
        unsigned int blockSize
    );
 
    AbstractProperty(
        const IndexTree &indexTree,
        unsigned int blockSize,
        const DataType *data
    );
 
    AbstractProperty(const AbstractProperty &abstractProperty);
 
    AbstractProperty(AbstractProperty &&abstractProperty);
 
    AbstractProperty(
        const std::string &serialization,
        Mode mode
    );
 
    virtual ~AbstractProperty();
 
    AbstractProperty& operator=(const AbstractProperty &abstractProperty);
 
    AbstractProperty& operator=(AbstractProperty &&abstractProperty);
 
    AbstractProperty& operator+=(const AbstractProperty &rhs);
 
    AbstractProperty& operator-=(const AbstractProperty &rhs);
 
    AbstractProperty& operator*=(const DataType &rhs);
 
    AbstractProperty& operator/=(const DataType &rhs);
private:
    IndexDescriptor indexDescriptor;
 
    unsigned int blockSize;
 
    std::vector<DataType> data;
 
    bool allowIndexOutOfBoundsAccess;
 
    DataType defaultValue;
 
    virtual void calculateDynamically(const Index &index, DataType *block);
};
 
template<typename DataType>
inline unsigned int AbstractProperty<DataType>::getBlockSize() const{
    return blockSize;
}
 
template<typename DataType>
inline unsigned int AbstractProperty<DataType>::getSize() const{
    return data.size();
}
 
template<typename DataType>
inline const std::vector<
    DataType
>& AbstractProperty<DataType>::getData() const{
    return data;
}
 
template<typename DataType>
inline std::vector<DataType>& AbstractProperty<DataType>::getDataRW(){
    return data;
}
 
template<typename DataType>
inline unsigned int AbstractProperty<DataType>::getDimensions() const{
    return indexDescriptor.getRanges().size();
}
 
template<typename DataType>
inline std::vector<int> AbstractProperty<DataType>::getRanges() const{
    return indexDescriptor.getRanges();
}
 
template<typename DataType>
inline int AbstractProperty<DataType>::getOffset(
    const Index &index
) const{
    return blockSize*indexDescriptor.getLinearIndex(
        index,
        allowIndexOutOfBoundsAccess
    );
}
 
template<typename DataType>
inline const IndexDescriptor& AbstractProperty<DataType>::getIndexDescriptor(
) const{
    return indexDescriptor;
}
 
template<typename DataType>
inline bool AbstractProperty<DataType>::contains(
    const Index &index
) const{
    return indexDescriptor.contains(index);
}
 
template<typename DataType>
inline void AbstractProperty<DataType>::reduce(
    const std::vector<Index> &targetPatterns,
    const std::vector<Index> &newPatterns
){
    TBTKAssert(
        targetPatterns.size() == newPatterns.size(),
        "AbstractProperty::reduce()",
        "The size of targetPatterns '" << targetPatterns.size() << "'"
        << " must be the same as the size of newPatterns '"
        << newPatterns.size() << "'.",
        ""
    );
 
    IndexTree newIndexTree;
    const IndexTree &oldIndexTree = indexDescriptor.getIndexTree();
    IndexedDataTree<Index> indexMap;
    IndexedDataTree<Index> reverseIndexMap;
    for(
        IndexTree::ConstIterator iterator = oldIndexTree.cbegin();
        iterator != oldIndexTree.cend();
        ++iterator
    ){
 
        int matchingPattern = -1;
        for(unsigned int n = 0; n < targetPatterns.size(); n++){
            if(targetPatterns[n].equals(*iterator, true)){
                matchingPattern = n;
                break;
            }
        }
        if(matchingPattern == -1)
            continue;
 
        Index newIndex = newPatterns[matchingPattern];
        for(unsigned int n = 0; n < newIndex.getSize(); n++){
            if(newIndex[n].isLabeledWildcard()){
                for(
                    unsigned int c = 0;
                    c < targetPatterns[
                        matchingPattern
                    ].getSize();
                    c++
                ){
                    if(
                        targetPatterns[
                            matchingPattern
                        ][c] == newIndex[n]
                    ){
                        newIndex[n] = (*iterator)[c];
                        break;
                    }
                }
            }
        }
        TBTKAssert(
            !newIndexTree.contains(newIndex),
            "AbstractProperty::reduce()",
            "Conflicting index reductions. The indices '"
            << (*iterator).toString() << "' and '"
            << reverseIndexMap.get(newIndex).toString() << "' both"
            << " reduce to '" << newIndex.toString() << "'.",
            ""
        );
        indexMap.add(newIndex, (*iterator));
        reverseIndexMap.add((*iterator), newIndex);
        newIndexTree.add(newIndex);
    }
    newIndexTree.generateLinearMap();
 
    IndexDescriptor newIndexDescriptor(newIndexTree);
    std::vector<DataType> newData;
    for(unsigned int n = 0; n < indexDescriptor.getSize()*blockSize; n++)
        newData.push_back(0.);
 
    for(
        IndexedDataTree<Index>::ConstIterator iterator
            = indexMap.cbegin();
        iterator != indexMap.cend();
        ++iterator
    ){
        const Index &oldIndex = iterator.getCurrentIndex();
        const Index &newIndex = *iterator;
        for(unsigned int n = 0; n < blockSize; n++){
            newData[
                blockSize*newIndexDescriptor.getLinearIndex(
                    newIndex
                ) + n
            ] = data[
                blockSize*indexDescriptor.getLinearIndex(
                    oldIndex
                ) + n
            ];
        }
    }
 
    indexDescriptor = newIndexDescriptor;
    data = newData;
}
 
template<typename DataType>
inline void AbstractProperty<DataType>::hermitianConjugate(){
    IndexTree newIndexTree;
    const IndexTree &oldIndexTree = indexDescriptor.getIndexTree();
    IndexedDataTree<Index> indexMap;
    IndexedDataTree<Index> transposedIndexMap;
    for(
        IndexTree::ConstIterator iterator = oldIndexTree.cbegin();
        iterator != oldIndexTree.cend();
        ++iterator
    ){
        std::vector<Index> components = (*iterator).split();
        TBTKAssert(
            components.size() == 2,
            "AbstractProperty<DataType>::hermitianConjugate()",
            "Invalid Index structure. Unable to performorm the"
            << " Hermitian conjugation because the Index '"
            << (*iterator).toString() << "' is not a compound"
            << " Index with two component Indices.",
            ""
        );
        newIndexTree.add({components[1], components[0]});
    }
    newIndexTree.generateLinearMap();
 
    IndexDescriptor newIndexDescriptor(newIndexTree);
    std::vector<DataType> newData;
    for(unsigned int n = 0; n < indexDescriptor.getSize()*blockSize; n++)
        newData.push_back(0.);
 
    for(
        IndexTree::ConstIterator iterator = oldIndexTree.cbegin();
        iterator != oldIndexTree.cend();
        ++iterator
    ){
        for(unsigned int n = 0; n < blockSize; n++){
            std::vector<Index> components = (*iterator).split();
            newData[
                blockSize*newIndexDescriptor.getLinearIndex(
                    {components[1], components[0]}
                ) + n
            ] = conj(
                data[
                    blockSize*indexDescriptor.getLinearIndex(
                        *iterator
                    ) + n
                ]
            );
        }
    }
 
    indexDescriptor = newIndexDescriptor;
    data = newData;
}
 
template<typename DataType>
inline std::vector<SparseMatrix<DataType>> AbstractProperty<
    DataType
>::toSparseMatrices(
    const Model &model
) const{
    const HoppingAmplitudeSet &hoppingAmplitudeSet
        = model.getHoppingAmplitudeSet();
 
    std::vector<SparseMatrix<DataType>> sparseMatrices;
    for(unsigned int n = 0; n < blockSize; n++){
        sparseMatrices.push_back(
            SparseMatrix<DataType>(
                SparseMatrix<DataType>::StorageFormat::CSC,
                model.getBasisSize(),
                model.getBasisSize()
            )
        );
    }
    const IndexTree &indexTree = indexDescriptor.getIndexTree();
    for(
        IndexTree::ConstIterator iterator = indexTree.cbegin();
        iterator != indexTree.cend();
        ++iterator
    ){
        std::vector<Index> components = (*iterator).split();
        TBTKAssert(
            components.size() == 2,
            "AbstractProperty<DataType>::toSparseMatrices()",
            "Invalid Index structure. Unable to convert to"
            << "SparseMatrices because the Index '"
            << (*iterator).toString() << "' is not a compound"
            << " Index with two component Indices.",
            ""
        );
        unsigned int row
            = hoppingAmplitudeSet.getBasisIndex(components[0]);
        unsigned int column
            = hoppingAmplitudeSet.getBasisIndex(components[1]);
        unsigned int offset
            = blockSize*indexDescriptor.getLinearIndex(*iterator);
        for(unsigned int n = 0; n < blockSize; n++)
            sparseMatrices[n].add(row, column, data[offset + n]);
    }
    for(unsigned int n = 0; n < blockSize; n++)
        sparseMatrices[n].construct();
 
    return sparseMatrices;
}
 
template<typename DataType>
inline const DataType& AbstractProperty<DataType>::operator()(
    const Index &index,
    unsigned int offset
) const{
    int indexOffset = getOffset(index);
    if(indexOffset < 0)
        return defaultValue;
    else
        return data[indexOffset + offset];
}
 
template<typename DataType>
inline DataType& AbstractProperty<DataType>::operator()(
    const Index &index,
    unsigned int offset
){
    int indexOffset = getOffset(index);
    if(indexOffset < 0){
        static DataType defaultValueNonConst;
        defaultValueNonConst = defaultValue;
        return defaultValueNonConst;
    }
    else{
        return data[indexOffset + offset];
    }
}
 
template<typename DataType>
inline DataType& AbstractProperty<DataType>::operator()(
    const std::initializer_list<Subindex> &index
){
    return operator()(index, 0);
}
 
template<typename DataType>
inline const DataType& AbstractProperty<DataType>::operator()(
    const std::initializer_list<Subindex> &index
) const{
    return operator()(index, 0);
}
 
/*template<typename DataType>
inline DataType& AbstractProperty<DataType>::operator()(
    const std::initializer_list<unsigned int> &index
){
    return operator()(index, 0);
}
 
template<typename DataType>
inline const DataType& AbstractProperty<DataType>::operator()(
    const std::initializer_list<unsigned int> &index
) const{
    return operator()(index, 0);
}*/
 
template<typename DataType>
inline const DataType& AbstractProperty<DataType>::operator()(
    unsigned int offset
) const{
    return data[offset];
}
 
template<typename DataType>
inline DataType& AbstractProperty<DataType>::operator()(unsigned int offset){
    return data[offset];
}
 
template<typename DataType>
inline void AbstractProperty<DataType>::setAllowIndexOutOfBoundsAccess(
    bool allowIndexOutOfBoundsAccess
){
    this->allowIndexOutOfBoundsAccess = allowIndexOutOfBoundsAccess;
}
 
template<typename DataType>
inline void AbstractProperty<DataType>::setDefaultValue(
    const DataType &defaultValue
){
    this->defaultValue = defaultValue;
}
 
template<typename DataType>
inline void AbstractProperty<DataType>::replaceValues(
    const DataType &targetValue,
    const DataType &replacementValue
){
    //Handle NaN values.
    if(targetValue != targetValue){
        for(unsigned int n = 0; n < data.size(); n++)
            if(data[n] != data[n])
                data[n] = replacementValue;
 
        return;
    }
 
    for(unsigned int n = 0; n < data.size(); n++)
        if(data[n] == targetValue)
            data[n] = replacementValue;
}
 
template<typename DataType>
inline std::string AbstractProperty<DataType>::toString() const{
    return "AbstractProperty";
}
 
template<typename DataType>
inline std::string AbstractProperty<DataType>::serialize(Mode mode) const{
    switch(mode){
    case Mode::JSON:
    {
        nlohmann::json j;
        j["id"] = "AbstractProperty";
        j["indexDescriptor"] = nlohmann::json::parse(
            indexDescriptor.serialize(mode)
        );
        j["blockSize"] = blockSize;
        for(unsigned int n = 0; n < data.size(); n++){
            //Convert the reference data[n] to an actual bool to
            //get the code to compile on Mac. Some issue with the
            //nlohmann library on Mac. Replace by the single
            //commented out line when it is working again.
            j["data"].push_back(
                Serializable::serialize(data[n], mode)
            );
        }
 
        j["allowIndexOutOfBoundsAccess"] = allowIndexOutOfBoundsAccess;
        j["defaultValue"] = Serializable::serialize(defaultValue, mode);
 
        return j.dump();
    }
    default:
        TBTKExit(
            "AbstractProperty<DataType>::serialize()",
            "Only Serializable::Mode::JSON is supported yet.",
            ""
        );
    }
}
 
template<typename DataType>
AbstractProperty<DataType>::AbstractProperty() : indexDescriptor(){
    this->blockSize = 0;
 
    allowIndexOutOfBoundsAccess = false;
}
 
template<typename DataType>
AbstractProperty<DataType>::AbstractProperty(
    unsigned int blockSize
) :
    indexDescriptor()
{
    this->blockSize = blockSize;
 
    unsigned int size = blockSize;
    data.reserve(size);
    for(unsigned int n = 0; n < size; n++)
        data.push_back(0.);
 
    allowIndexOutOfBoundsAccess = false;
}
 
template<typename DataType>
AbstractProperty<DataType>::AbstractProperty(
    unsigned int blockSize,
    const DataType *data
) :
    indexDescriptor()
{
    this->blockSize = blockSize;
 
    unsigned int size = blockSize;
    this->data.reserve(size);
    for(unsigned int n = 0; n < size; n++)
        this->data.push_back(data[n]);
 
    allowIndexOutOfBoundsAccess = false;
}
 
template<typename DataType>
AbstractProperty<DataType>::AbstractProperty(
    const std::vector<int> &ranges,
    unsigned int blockSize
) :
    indexDescriptor(ranges)
{
    this->blockSize = blockSize;
 
    unsigned int size = blockSize*indexDescriptor.getSize();
    data.reserve(size);
    for(unsigned int n = 0; n < size; n++)
        data.push_back(DataType(0.));
 
    allowIndexOutOfBoundsAccess = false;
}
 
template<typename DataType>
AbstractProperty<DataType>::AbstractProperty(
    const std::vector<int> &ranges,
    unsigned int blockSize,
    const DataType *data
) :
    indexDescriptor(ranges)
{
    this->blockSize = blockSize;
 
    unsigned int size = blockSize*indexDescriptor.getSize();
    this->data.reserve(size);
    for(unsigned int n = 0; n < size; n++)
        this->data.push_back(data[n]);
 
    allowIndexOutOfBoundsAccess = false;
}
 
template<typename DataType>
AbstractProperty<DataType>::AbstractProperty(
    const IndexTree &indexTree,
    unsigned int blockSize
) :
    indexDescriptor(indexTree)
{
    TBTKAssert(
        indexTree.getLinearMapIsGenerated(),
        "AbstractProperty::AbstractProperty()",
        "Linear map not constructed for the IndexTree.",
        "Call IndexTree::generateLinearIndex() before passing the"
        " IndexTree to the AbstractProperty constructor."
    );
 
    this->blockSize = blockSize;
 
    unsigned int size = blockSize*indexDescriptor.getSize();
    data.reserve(size);
    for(unsigned int n = 0; n < size; n++)
        data.push_back(DataType(0.));
 
    allowIndexOutOfBoundsAccess = false;
}
 
template<typename DataType>
AbstractProperty<DataType>::AbstractProperty(
    const IndexTree &indexTree,
    unsigned int blockSize,
    const DataType *data
) :
    indexDescriptor(indexTree)
{
    TBTKAssert(
        indexTree.getLinearMapIsGenerated(),
        "AbstractProperty::AbstractProperty()",
        "Linear map not constructed for the IndexTree.",
        "Call IndexTree::generateLinearIndex() before passing the"
        " IndexTree to the AbstractProperty constructor."
    );
 
    this->blockSize = blockSize;
 
    unsigned int size = blockSize*indexDescriptor.getSize();
    this->data.reserve(size);
    for(unsigned int n = 0; n < size; n++)
        this->data.push_back(data[n]);
 
    allowIndexOutOfBoundsAccess = false;
}
 
template<typename DataType>
AbstractProperty<DataType>::AbstractProperty(
    const AbstractProperty &abstractProperty
) :
    indexDescriptor(abstractProperty.indexDescriptor)
{
    blockSize = abstractProperty.blockSize;
 
    data = abstractProperty.data;
 
    allowIndexOutOfBoundsAccess
        = abstractProperty.allowIndexOutOfBoundsAccess;
}
 
template<typename DataType>
AbstractProperty<DataType>::AbstractProperty(
    AbstractProperty &&abstractProperty
) :
    indexDescriptor(std::move(abstractProperty.indexDescriptor))
{
    blockSize = abstractProperty.blockSize;
 
    data = abstractProperty.data;
 
    allowIndexOutOfBoundsAccess
        = abstractProperty.allowIndexOutOfBoundsAccess;
}
 
template<typename DataType>
inline AbstractProperty<DataType>::AbstractProperty(
    const std::string &serialization,
    Mode mode
) :
    indexDescriptor(
        Serializable::extract(serialization, mode, "indexDescriptor"),
        mode
    )
{
    TBTKAssert(
        validate(serialization, "AbstractProperty", mode),
        "AbstractProperty::AbstractProperty()",
        "Unable to parse string as AbstractProperty '" << serialization
        << "'.",
        ""
    );
 
    switch(mode){
    case Mode::JSON:
        try{
            nlohmann::json j = nlohmann::json::parse(serialization);
            blockSize = j.at("blockSize").get<unsigned int>();
            nlohmann::json d = j.at("data");
            for(
                nlohmann::json::iterator it = d.begin();
                it < d.end();
                ++it
            ){
                data.push_back(
                    Serializable::deserialize<DataType>(
                        it->get<std::string>(),
                        mode
                    )
                );
            }
 
            allowIndexOutOfBoundsAccess = j.at(
                "allowIndexOutOfBoundsAccess"
            ).get<bool>();
            defaultValue = Serializable::deserialize<DataType>(
                j.at("defaultValue").get<std::string>(),
                mode
            );
        }
        catch(nlohmann::json::exception &e){
            TBTKExit(
                "AbstractProperty::AbstractProperty()",
                "Unable to parse string as AbstractProperty '"
                << serialization << "'.",
                ""
            );
        }
 
        break;
    default:
        TBTKExit(
            "AbstractProperty::AbstractProperty()",
            "Only Serializable::Mode::JSON is supported yet.",
            ""
        );
    }
}
 
template<typename DataType>
inline AbstractProperty<DataType>::~AbstractProperty(){
}
 
template<typename DataType>
AbstractProperty<DataType>& AbstractProperty<DataType>::operator=(
    const AbstractProperty &rhs
){
    if(this != &rhs){
        indexDescriptor = rhs.indexDescriptor;
 
        blockSize = rhs.blockSize;
 
        data = rhs.data;
 
        allowIndexOutOfBoundsAccess = rhs.allowIndexOutOfBoundsAccess;
    }
 
    return *this;
}
 
template<typename DataType>
AbstractProperty<DataType>& AbstractProperty<DataType>::operator=(
    AbstractProperty &&rhs
){
    if(this != &rhs){
        indexDescriptor = std::move(rhs.indexDescriptor);
 
        blockSize = rhs.blockSize;
 
        data = rhs.data;
 
        allowIndexOutOfBoundsAccess = rhs.allowIndexOutOfBoundsAccess;
    }
 
    return *this;
}
 
template<typename DataType>
inline AbstractProperty<DataType>&
AbstractProperty<DataType>::operator+=(const AbstractProperty<DataType> &rhs){
    TBTKAssert(
        indexDescriptor == rhs.indexDescriptor,
        "AbstractProperty::operator+=()",
        "Incompatible Properties. The Properties does not have the"
        << " same index structure.",
        ""
    );
 
    TBTKAssert(
        blockSize == rhs.blockSize,
        "AbstractProperty::operator+=()",
        "Incompatible Properties. The Properties does not have the"
        << " same block size.",
        ""
    );
 
    TBTKAssert(
        allowIndexOutOfBoundsAccess == rhs.allowIndexOutOfBoundsAccess,
        "AbstractProperty::operator+=()",
        "Incompatible Properties. The Properties differ in their"
        << " 'index out of bounds behavior'.",
        "Use AbstractProperty::setAllowIndexOutOfBoundsAccess() to set"
        << " the 'index out of bounds' behavior."
    );
 
    if(allowIndexOutOfBoundsAccess){
        TBTKAssert(
            defaultValue == rhs.defaultValue,
            "AbstractProperty::operator+=()",
            "Incompatible Properties. The Properties differ in"
            << " their default values.",
            "Use AbstractProperty::setDefaultValue() to set the"
            << " default value."
        );
    }
 
    TBTKAssert(
        data.size() == rhs.data.size(),
        "AbstractProperty::operator+=()",
        "Incompatible Properties. The Properties have different data"
        << " sizes.",
        "This should never happen, contact the developer."
    );
 
    for(unsigned int n = 0; n < data.size(); n++)
        data[n] += rhs.data[n];
 
    return *this;
}
 
template<typename DataType>
inline AbstractProperty<DataType>&
AbstractProperty<DataType>::operator-=(
    const AbstractProperty<DataType> &rhs
){
    TBTKAssert(
        indexDescriptor == rhs.indexDescriptor,
        "AbstractProperty::operator-=()",
        "Incompatible Properties. The Properties does not have the"
        << " same index structure.",
        ""
    );
 
    TBTKAssert(
        blockSize == rhs.blockSize,
        "AbstractProperty::operator-=()",
        "Incompatible Properties. The Properties does not have the"
        << " same block size.",
        ""
    );
 
    TBTKAssert(
        allowIndexOutOfBoundsAccess == rhs.allowIndexOutOfBoundsAccess,
        "AbstractProperty::operator-=()",
        "Incompatible Properties. The Properties differ in their"
        << " 'index out of bounds behavior'.",
        "Use AbstractProperty::setAllowIndexOutOfBoundsAccess() to set"
        << " the 'index out of bounds' behavior."
    );
 
    if(allowIndexOutOfBoundsAccess){
        TBTKAssert(
            defaultValue == rhs.defaultValue,
            "AbstractProperty::operator-=()",
            "Incompatible Properties. The Properties differ in"
            << " their default values.",
            "Use AbstractProperty::setDefaultValue() to set the"
            << " default value."
        );
    }
 
    TBTKAssert(
        data.size() == rhs.data.size(),
        "AbstractProperty::operator-=()",
        "Incompatible Properties. The Properties have different data"
        << " sizes.",
        "This should never happen, contact the developer."
    );
 
    for(unsigned int n = 0; n < data.size(); n++)
        data[n] -= rhs.data[n];
 
    return *this;
}
 
template<typename DataType>
inline AbstractProperty<DataType>&
AbstractProperty<DataType>::operator*=(
    const DataType &rhs
){
    if(allowIndexOutOfBoundsAccess)
        defaultValue *= rhs;
 
    for(unsigned int n = 0; n < data.size(); n++)
        data[n] *= rhs;
 
    return *this;
}
 
template<typename DataType>
inline AbstractProperty<DataType>& AbstractProperty<DataType>::operator/=(
    const DataType &rhs
){
    if(allowIndexOutOfBoundsAccess)
        defaultValue /= rhs;
 
    for(unsigned int n = 0; n < data.size(); n++)
        data[n] /= rhs;
 
    return *this;
}
 
template<typename DataType>
void AbstractProperty<DataType>::calculateDynamically(
    const Index &index,
    DataType *block
){
    TBTKExit(
        "AbstractProperty::calculateDynamically()",
        "This Property does not support dynamic calculation.",
        ""
    );
}
 
};  //End namespace Property
};  //End namespace TBTK
 
#endif