Make Basis singleton

[rafaelrojasmiliani]

Motivation

The Basis represent an abstract mathematical object that is unique, in the sense that it only provide the evaluations of objects that do not change. In the same sense, they must not have a state. Basis are stateless. I have used mutable private variables to improve performance and avoid creating new objects.

Because its abstract and unique nature, Basis must exists in a unique non writable instance.

Proposed solution

class Base {};

template <typename Current> class Helper {
public:
  template <typename... Ts> static std::shared_ptr<Current> get(Ts &&... args) {
    auto const values{std::make_tuple(args...)};

    static std::map<std::tuple<Ts...>, std::shared_ptr<Current>> database;

    if (database.find(values) == database.end()) {
      database[values] = std::make_shared<Current>(args...);
    }

    return database[values];
  }
};
int main() { return 0; }

[rafaelrojasmiliani]

See how to implement unordered maps with custom comparison operators. This is linked to #42

• How to hash combine

[rafaelrojasmiliani]

We can proceed as follows:

1. Implement the characterization of a basis with the following elements
   • Array of double parameters
   • Array of int parameters
   • string with name
   • dimension
2. Implement a Base hasher and a comparision
3. Implement an inheritance helper

class Base{
private:
template<T> friend BaseInheritaceHelper<T>;
static std::shared_ptr<Current> add();
}
template <typename Current> class BaseInheritanceHelper : public: Base {
public:

  template <typename... Ts>
  static std::shared_ptr<Current> get(Ts &&... args) {
    
   std::shared_ptr<Current>self = std::make_shared<Current>(args);
   BasisIndexer index = self->get_index();
   if(not Basis::get(index)){
    Basis::add(self);
   }
  return Basis::get(index);
  }
BaseInheritanceHelper::BaseInheritanceHelper(/*same base arguments*/): Base(/*args*/){
if(not self)
 trow std::valueError("this must be a singelton");
}
public:
std::shared_ptr<Current> get_ptr() const {
return self;
}
const std::shared_ptr<Current> get_ptr() const {
return Base::get(get_index())
}
private:
protected:

};
int main() { return 0; }