FuzzySet.h

Go to the documentation of this file.

 
#pragma once
 
#include <functional>
#include <map>
#include <memory>
#include <optional>
#include <string>
#include <variant>
 
#include "CrispSet.h"
#include "autopas/options/Option.h"
#include "autopas/utils/ExceptionHandler.h"
 
namespace autopas::FuzzyLogic {
 
class DefuzzificationMethodOption : public Option<DefuzzificationMethodOption> {
 public:
  enum Value {
    CoG,
    MoM
  };
 
  DefuzzificationMethodOption() = default;
 
  constexpr DefuzzificationMethodOption(Value option) : _value(option) {}
 
  constexpr operator Value() const { return _value; }
 
  static std::map<DefuzzificationMethodOption, std::string> getOptionNames() {
    return {
        {DefuzzificationMethodOption::CoG, "centerOfGravity"},
        {DefuzzificationMethodOption::MoM, "meanOfMaximum"},
    };
  };
 
 private:
  Value _value{Value(-1)};
};
 
class FuzzySet {
 public:
  using Data = std::map<std::string, double>;
 
  using ComposedMembershipFunction = std::function<double(const Data &)>;
 
  using BaseMembershipFunction = std::tuple<std::string, std::vector<double>, std::function<double(double)>>;
 
  FuzzySet(std::string linguisticTerm, BaseMembershipFunction &&baseMembershipFunction);
 
  FuzzySet(std::string linguisticTerm, ComposedMembershipFunction &&membershipFunction,
           const std::shared_ptr<CrispSet> &crispSet);
 
  [[nodiscard]] double evaluate_membership(const Data &data) const;
 
  [[nodiscard]] double defuzzify(DefuzzificationMethodOption method, size_t numSamples) const;
 
  [[nodiscard]] std::string printBaseMembershipFunction() const;
 
  explicit operator std::string() const;
 
  [[nodiscard]] const std::string &getLinguisticTerm() const;
 
  [[nodiscard]] const std::shared_ptr<CrispSet> &getCrispSet() const;
 
  void setCrispSet(const std::shared_ptr<CrispSet> &crispSet);
 
  friend std::shared_ptr<FuzzySet> operator||(const std::shared_ptr<FuzzySet> &lhs,
                                              const std::shared_ptr<FuzzySet> &rhs);
 
  friend std::shared_ptr<FuzzySet> operator&&(const std::shared_ptr<FuzzySet> &lhs,
                                              const std::shared_ptr<FuzzySet> &rhs);
 
  friend std::shared_ptr<FuzzySet> operator!(const std::shared_ptr<FuzzySet> &fuzzySet);
 
 private:
  std::string _linguisticTerm;
 
  std::variant<BaseMembershipFunction, ComposedMembershipFunction> _membershipFunction;
 
  std::shared_ptr<CrispSet> _crispSet;
 
  [[nodiscard]] double centerOfGravity(size_t numSamples) const;
 
  [[nodiscard]] double meanOfMaximum(size_t numSamples) const;
};
 
std::shared_ptr<FuzzySet> operator||(const std::shared_ptr<FuzzySet> &lhs, const std::shared_ptr<FuzzySet> &rhs);
 
std::shared_ptr<FuzzySet> operator&&(const std::shared_ptr<FuzzySet> &lhs, const std::shared_ptr<FuzzySet> &rhs);
 
std::shared_ptr<FuzzySet> operator!(const std::shared_ptr<FuzzySet> &fuzzySet);
 
}  // namespace autopas::FuzzyLogic