Core.hpp

Go to the documentation of this file.

#ifndef AI_TOOLBOX_FACTORED_UTILS_HEADER_FILE
#define AI_TOOLBOX_FACTORED_UTILS_HEADER_FILE
 
#include <AIToolbox/Factored/Types.hpp>
 
namespace AIToolbox::Factored {
    enum class TagErrors {
        None,
        NoElements,
        TooManyElements,
        IdTooHigh,
        NotSorted,
        Duplicates,
    };
 
    std::pair<TagErrors, size_t> checkTag(const Factors & space, const PartialKeys & tag);
 
    PartialFactors removeFactor(const PartialFactors & pf, size_t f);
 
    template <typename Gen>
    Factors makeRandomValue(const Factors & space, Gen & rnd) {
        Factors retval(space.size());
        for (size_t i = 0; i < space.size(); ++i) {
            std::uniform_int_distribution<size_t> dist(0, space[i]-1);
            retval[i] = dist(rnd);
        }
        return retval;
    }
 
    bool match(const PartialFactors & lhs, const PartialFactors & rhs);
 
    bool match(const Factors & lhs, const PartialFactors & rhs);
 
    bool match(const PartialKeys & lhsK, const PartialValues & lhs, const PartialKeys & rhsK, const PartialValues & rhs);
 
    bool match(const PartialKeys & keys, const Factors & lhs, const Factors & rhs);
 
    bool match(const std::vector<std::pair<size_t, size_t>> & matches, const Factors & lhs, const Factors & rhs);
 
    void join(size_t S, PartialFactors * lhs, const PartialFactors & rhs);
 
    Factors join(const Factors & lhs, const Factors & rhs);
 
    PartialKeys join(size_t S, const PartialKeys & lhs, const PartialKeys & rhs);
 
    PartialFactors join(size_t S, const PartialFactors & lhs, const PartialFactors & rhs);
 
    void unsafe_join(PartialFactors * lhs, const PartialFactors & rhs);
 
    PartialFactors merge(const PartialFactors & lhs, const PartialFactors & rhs);
 
    PartialValues merge(const PartialKeys & lhsk, const PartialValues & lhs, const PartialKeys & rhsk, const PartialValues & rhs);
 
    PartialKeys merge(const PartialKeys & lhs, const PartialKeys & rhs, std::vector<std::pair<size_t, size_t>> * matches = nullptr);
 
    size_t factorSpace(const Factors & space);
 
    size_t factorSpacePartial(const PartialKeys & ids, const Factors & space);
 
    PartialFactors toPartialFactors(const Factors & f);
 
    Factors toFactors(size_t F, const PartialFactors & pf);
 
    Factors toFactors(const Factors & space, size_t id);
 
    void toFactors(const Factors & space, size_t id, Factors * out);
 
    PartialValues toFactorsPartial(const PartialKeys & ids, const Factors & space, size_t id);
 
    template <typename It>
    void toFactorsPartial(It begin, const PartialKeys & ids, const Factors & space, size_t id) {
        for (auto key : ids) {
            *begin = id % space[key];
            id /= space[key];
            ++begin;
        }
    }
 
    size_t toIndex(const Factors & space, const Factors & f);
 
    size_t toIndex(const Factors & space, const PartialFactors & f);
 
    size_t toIndexPartial(const PartialKeys & ids, const Factors & space, const Factors & f);
 
    size_t toIndexPartial(const PartialKeys & ids, const Factors & space, const PartialFactors & pf);
 
    size_t toIndexPartial(const Factors & space, const PartialFactors & f);
 
    std::pair<size_t, size_t> toIndexPartialAndSkip(const PartialKeys & ids, const Factors & space, const Factors & f, size_t id);
 
    class PartialFactorsEnumerator {
        public:
            PartialFactorsEnumerator(Factors f, PartialKeys factors);
 
            PartialFactorsEnumerator(Factors f);
 
            PartialFactorsEnumerator(Factors f, const PartialKeys & factors, size_t factorToSkip, bool missing = false);
 
            PartialFactorsEnumerator(Factors f, size_t factorToSkip);
 
            size_t getFactorToSkipId() const;
 
            void advance();
 
            bool isValid() const;
 
            void reset();
 
            size_t size() const;
 
            PartialFactors& operator*();
 
            PartialFactors* operator->();
 
        private:
            Factors F;
            PartialFactors factors_;
            size_t factorToSkipId_;
    };
 
    class PartialIndexEnumerator {
        public:
            PartialIndexEnumerator(const Factors & F, size_t fixedFactor, size_t val);
 
            PartialIndexEnumerator(const Factors & F, const PartialKeys & factors, size_t fixedFactor, size_t val, bool missing = false);
 
            size_t operator*() const;
 
            void advance();
 
            bool isValid();
 
            void reset();
 
        private:
            size_t len_;
            size_t skip_;
            size_t offset_;
            size_t curr_, currLen_;
            size_t max_;
    };
}
 
#endif