Subindex.h

Go to the documentation of this file.

/* Copyright 2019 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_SUBINDEX
#define COM_DAFER45_TBTK_SUBINDEX

#include "TBTK/Integer.h"
#include "TBTK/Natural.h"
#include "TBTK/PseudoSerializable.h"

#ifndef TBTK_DISABLE_NLOHMANN_JSON
#   include "TBTK/json.hpp"
#endif

namespace TBTK{

#if TBTK_WRAP_PRIMITIVE_TYPES

class Subindex : PseudoSerializable{
public:
    //TBTKFeature Core.Subindex.Construction.1 2019-09-22
    Subindex(){};

    //TBTKFeature Core.Subindex.Construction.2.C++ 2019-09-22
    constexpr Subindex(Integer value) : value(value) {}

    //TBTKFeature Core.Subindex.Construction.2.C++ 2019-09-22
    constexpr Subindex(int value) : value(value) {}

    //TBTKFeature Core.Subindex.Construction.2.C++ 2019-09-22
    constexpr Subindex(unsigned int value) : value(value) {}

    //TBTKFeature Core.Subindex.Serialization.1 2019-09-22
    Subindex(const std::string &serialization, Serializable::Mode mode);

    //TBTKFeature Core.Subindex.isWildcard.1 2019-09-22
    //TBTKFeature Core.Subindex.isWildcard.2 2019-09-22
    bool isWildcard() const;

    //TBTKFeature Core.Subindex.isLabeledWildcard.1 2019-09-22
    //TBTKFeature Core.Subindex.isLabeledWildcard.2 2019-09-22
    bool isLabeledWildcard() const;

    Subindex getWildcardLabel() const;

    //TBTKFeature Core.Subindex.isSummationIndex.1 2019-09-22
    //TBTKFeature Core.Subindex.isSummationIndex.2 2019-09-22
    bool isSummationIndex() const;

    bool isRangeIndex() const;

    //TBTKFeature Core.Subindex.isSpinIndex.1 2019-09-22
    //TBTKFeature Core.Subindex.isSpinIndex.2 2019-09-22
    bool isSpinIndex() const;

    //TBTKFeature Core.Subindex.isIndexSeparator.1 2019-09-22
    //TBTKFeature Core.Subindex.isIndexSeparator.2 2019-09-22
    bool isIndexSeparator() const;

    //TBTKFeature Core.Subindex.operatorInt.1.C++ 2019-09-22
    constexpr operator int() const{ return value;   };

    //TBTKFeature Core.Subindex.operatorAssignment.1.C++ 2019-09-22
    Subindex& operator=(Integer rhs){
        value = rhs;

        return *this;
    }

    //TBTKFeature Core.Subindex.operatorAssignment.1.C++ 2019-09-22
    Subindex& operator=(int rhs){
        value = rhs;

        return *this;
    }

    //TBTKFeature Core.Subindex.operatorAdditionAssignment.1.C++ 2019-09-22
    Subindex& operator+=(Subindex rhs){
        value += rhs.value;

        return *this;
    }

    //TBTKFeature Core.Subindex.operatorSubtractionAssignment.1.C++ 2019-09-22
    Subindex& operator-=(Subindex rhs){
        value -= rhs.value;

        return *this;
    }

    //TBTKFeature Core.Subindex.operatorMultiplicationAssignment.1.C++ 2019-09-22
    Subindex& operator*=(Subindex rhs){
        value *= rhs.value;

        return *this;
    }

    //TBTKFeature Core.Subindex.operatorDivisionAssignment.1.C++ 2019-09-22
    Subindex& operator/=(Subindex rhs){
        value /= rhs.value;

        return *this;
    }

    //TBTKFeature Core.Subindex.operatorPreIncrement.1.C++ 2019-09-22
    Subindex& operator++(){
        value++;

        return *this;
    }

    //TBTKFeature Core.Subindex.operatorPostIncrement.1.C++ 2019-09-22
    Subindex operator++(int){
        Subindex previous(*this);
        operator++();

        return previous;
    }

    //TBTKFeature Core.Subindex.operatorPreDecrement.1.C++ 2019-09-22
    Subindex& operator--(){
        value--;

        return *this;
    }

    //TBTKFeature Core.Subindex.operatorPostIncrement.1.C++ 2019-09-22
    Subindex operator--(int){
        Subindex previous(*this);
        operator--();

        return previous;
    }

    //TBTKFeature Core.Subindex.operatorFunction.1.C++ 2019-09-22
    //TBTKFeature Core.Subindex.operatorFunction.2.C++ 2019-09-22
    Subindex operator()(unsigned int label) const;

    friend std::ostream& operator<<(std::ostream &os, const Subindex subindex){
        os << subindex.value;

        return os;
    }

    friend std::istream& operator>>(std::istream &is, Subindex &subindex){
        int i;
        is >> i;
        subindex.value = Integer(i);

        return is;
    }

    std::string serialize(Serializable::Mode mode) const;

#ifndef TBTK_DISABLE_NLOHMANN_JSON

    friend void to_json(nlohmann::json &j, const Subindex &subindex){
        to_json(j, subindex.value);
    }

    friend void from_json(const nlohmann::json &j, Subindex &subindex){
        from_json(j, subindex.value);
    }
#endif
private:
    Integer value;
};

//_a_ and _aX_ are shorthand notation for IDX_ALL and IDX_ALL_. Never use
//shorthands in library code.
constexpr Subindex IDX_FLAG_MASK    = (int)0x00FFFFFF;
constexpr Subindex IDX_ALL      = (int)(0xBFFFFFFF & ~0x20000000);
constexpr Subindex _a_          = IDX_ALL;
constexpr Subindex IDX_SUM_ALL      = (int)(0xBFFFFFFF & ~0x20000001);
constexpr Subindex IDX_SPIN     = (int)(0xBFFFFFFF & ~0x20000002);
constexpr Subindex IDX_SEPARATOR    = (int)(0xBFFFFFFF & ~0x20000003);
constexpr Subindex IDX_ALL_     = (int)(0xBFFFFFFF & ~0x10000000);
constexpr Subindex _aX_         = IDX_ALL_;
constexpr Subindex IDX_RANGE        = (int)(0xBFFFFFFF & ~0x08000000);
constexpr Subindex IDX_X        = (int)(IDX_RANGE & ~0x00000000);
constexpr Subindex IDX_Y        = (int)(IDX_RANGE & ~0x00000001);
constexpr Subindex IDX_Z        = (int)(IDX_RANGE & ~0x00000002);

inline Subindex::Subindex(
    const std::string &serialization,
    Serializable::Mode mode
) :
    value(serialization, mode)
{
}

inline bool Subindex::isWildcard() const{
    return value == IDX_ALL;
}

inline bool Subindex::isLabeledWildcard() const{
    return (value | IDX_FLAG_MASK) == IDX_ALL_;
}

inline Subindex Subindex::getWildcardLabel() const{
    TBTKAssert(
        isLabeledWildcard(),
        "Subindex::getWildcardLabel()",
        "The Subindex is not a labeled wildcard.",
        ""
    );

    if((value & IDX_FLAG_MASK) == 0)
        return 0;
    else
        return Subindex(-(int)(value | ~IDX_FLAG_MASK));
}

inline bool Subindex::isSummationIndex() const{
    return value == IDX_SUM_ALL;
}

inline bool Subindex::isRangeIndex() const{
    return (value | IDX_FLAG_MASK) == IDX_RANGE;
}

inline bool Subindex::isSpinIndex() const{
    return value == IDX_SPIN;
}

inline bool Subindex::isIndexSeparator() const{
    return value == IDX_SEPARATOR;
}

inline Subindex Subindex::operator()(unsigned int label) const{
    TBTKAssert(
        value == IDX_ALL_.value,
        "Subindex::operator()",
        "Unsupported subindex type. This function is only supported"
        << " for the IDX_ALL_ Subindex.",
        ""
    );

    return Subindex(value & (-(int)label | ~IDX_FLAG_MASK));
}

inline std::string Subindex::serialize(Serializable::Mode mode) const{
    return value.serialize(mode);
}

#else
    typedef int Subindex;
#endif

};  //End of namespace TBTK

#endif