ArrayState.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_ARRAY_STATE
#define COM_DAFER45_TBTK_ARRAY_STATE
 
#include "TBTK/AbstractState.h"
#include "TBTK/DefaultOperator.h"
#include "TBTK/TBTKMacros.h"
 
#include <complex>
#include <sstream>
 
namespace TBTK{
 
class ArrayState : public AbstractState{
public:
    ArrayState(
        std::initializer_list<unsigned int> resolution
    );
 
    virtual ~ArrayState();
 
    virtual ArrayState* clone() const;
 
    virtual std::complex<double> getOverlap(const AbstractState &bra) const;
 
    virtual std::complex<double> getMatrixElement(
        const AbstractState &bra,
        const AbstractOperator &o = DefaultOperator()
    ) const;
 
    void setAmplitude(
        std::complex<double> amplitude,
        std::initializer_list<unsigned int> element
    );
 
    void setAmplitude(
        std::complex<double> amplitude,
        const std::vector<unsigned int> &element
    );
 
    void setAmplitude(
        std::complex<double> amplitude,
        const Index &element
    );
 
    const std::complex<double>& getAmplitude(
        std::initializer_list<unsigned int> element
    ) const;
 
    const std::complex<double>& getAmplitude(
        const std::vector<unsigned int> &element
    ) const;
 
    const std::complex<double>& getAmplitude(
        const Index &element
    ) const;
protected:
    const std::vector<unsigned int>& getResolution() const;
private:
    class Storage{
    public:
        Storage(std::initializer_list<unsigned int> resolution);
 
        ~Storage();
 
        void grab();
 
        bool release();
 
        void setElement(
            std::complex<double> value,
            std::initializer_list<unsigned int> element
        );
 
        void setElement(
            std::complex<double> value,
            const std::vector<unsigned int> &element
        );
 
        void setElement(
            std::complex<double> value,
            const Index &element
        );
 
        const std::complex<double>& getElement(
            std::initializer_list<unsigned int> element
        ) const;
 
        const std::complex<double>& getElement(
            const std::vector<unsigned int> &element
        ) const;
 
        const std::complex<double>& getElement(
            const Index &element
        ) const;
 
        const std::vector<unsigned int>& getResolution() const;
    private:
        unsigned int referenceCounter;
 
        std::complex<double> *data;
 
        std::vector<unsigned int> resolution;
    };
 
    Storage *storage;
};
 
inline void ArrayState::Storage::grab(){
    referenceCounter++;
}
 
inline bool ArrayState::Storage::release(){
    referenceCounter--;
    if(referenceCounter == 0)
        return true;
    else
        return false;
}
 
inline void ArrayState::setAmplitude(
    std::complex<double> amplitude,
    std::initializer_list<unsigned int> element
){
    storage->setElement(amplitude, element);
}
 
inline void ArrayState::setAmplitude(
    std::complex<double> amplitude,
    const std::vector<unsigned int> &element
){
    storage->setElement(amplitude, element);
}
 
inline void ArrayState::setAmplitude(
    std::complex<double> amplitude,
    const Index &element
){
    storage->setElement(amplitude, element);
}
 
inline const std::complex<double>& ArrayState::getAmplitude(
    std::initializer_list<unsigned int> element
) const{
    return storage->getElement(element);
}
 
inline const std::complex<double>& ArrayState::getAmplitude(
    const std::vector<unsigned int> &element
) const{
    return storage->getElement(element);
}
 
inline const std::complex<double>& ArrayState::getAmplitude(
    const Index &element
) const{
    return storage->getElement(element);
}
 
inline const std::vector<unsigned int>& ArrayState::getResolution() const{
    return storage->getResolution();
}
 
inline void ArrayState::Storage::setElement(
    std::complex<double> value,
    std::initializer_list<unsigned int> element
){
    unsigned int x = *(element.begin() + 0);
    unsigned int y = *(element.begin() + 1);
    unsigned int z = *(element.begin() + 2);
    data[resolution[2]*(resolution[1]*x + y) + z] = value;
}
 
inline void ArrayState::Storage::setElement(
    std::complex<double> value,
    const std::vector<unsigned int> &element
){
    unsigned int x = element.at(0);
    unsigned int y = element.at(1);
    unsigned int z = element.at(2);
    data[resolution[2]*(resolution[1]*x + y) + z] = value;
}
 
inline void ArrayState::Storage::setElement(
    std::complex<double> value,
    const Index &element
){
    unsigned int x = element.at(0);
    unsigned int y = element.at(1);
    unsigned int z = element.at(2);
    data[resolution[2]*(resolution[1]*x + y) + z] = value;
}
 
inline const std::complex<double>& ArrayState::Storage::getElement(
    std::initializer_list<unsigned int> element
) const{
    unsigned int x = *(element.begin() + 0);
    unsigned int y = *(element.begin() + 1);
    unsigned int z = *(element.begin() + 2);
    return data[resolution[2]*(resolution[1]*x + y) + z];
}
 
inline const std::complex<double>& ArrayState::Storage::getElement(
    const std::vector<unsigned int> &element
) const{
    unsigned int x = element.at(0);
    unsigned int y = element.at(1);
    unsigned int z = element.at(2);
    return data[resolution[2]*(resolution[1]*x + y) + z];
}
 
inline const std::complex<double>& ArrayState::Storage::getElement(
    const Index &element
) const{
    unsigned int x = element.at(0);
    unsigned int y = element.at(1);
    unsigned int z = element.at(2);
    return data[resolution[2]*(resolution[1]*x + y) + z];
}
 
inline const std::vector<unsigned int>& ArrayState::Storage::getResolution() const{
    return resolution;
}
 
};  //End of namespace TBTK
 
#endif