Renaming

include/fintamath/core/Cache.hpp

@@ -11,20 +11,20 @@ class Cache final {
   using Function = std::function<Value(const Key &)>;
 
 public:
-  explicit Cache(const Function &keyToValueFunction) : func(keyToValueFunction) {}
+  explicit Cache(const Function &inKeyToValueFunction) : keyToValueFunction(inKeyToValueFunction) {}
 
   const Value &operator[](const Key &key) {
-    if (!map.contains(key)) {
-      map[key] = func(key);
+    if (!keyToValueMap.contains(key)) {
+      keyToValueMap[key] = keyToValueFunction(key);
     }
 
-    return map.at(key);
+    return keyToValueMap.at(key);
   }
 
 private:
-  std::unordered_map<Key, Value> map;
+  std::unordered_map<Key, Value> keyToValueMap;
 
-  Function func;
+  Function keyToValueFunction;
 };
 
 }

include/fintamath/core/MathObjectTypes.hpp

@@ -206,10 +206,10 @@ namespace detail {
 class MathObjectBoundTypes final {
   using enum MathObjectType::Id;
 
-  using TypeToTypeMap = std::unordered_map<MathObjectType, MathObjectType, boost::hash<MathObjectType>>;
+  using TypeToBoundTypeMap = std::unordered_map<MathObjectType, MathObjectType, boost::hash<MathObjectType>>;
 
-  static TypeToTypeMap &getMutable() {
-    static TypeToTypeMap ids{
+  static TypeToBoundTypeMap &getMapMutable() {
+    static TypeToBoundTypeMap typeToBoundTypeMap{
         {IMathObject, None},
         {IArithmetic, ILiteral},
         {IExpression, IComparable},
@@ -224,24 +224,23 @@ class MathObjectBoundTypes final {
         {IFunction, None},
         {IOperator, None},
     };
-
-    return ids;
+    return typeToBoundTypeMap;
   }
 
 public:
-  static const TypeToTypeMap &get() {
-    return getMutable();
+  static const TypeToBoundTypeMap &getMap() {
+    return getMapMutable();
   }
 
-  static void reg(const MathObjectType &type, const MathObjectType &boundType) {
-    getMutable().emplace(type, boundType);
+  static void bindTypes(const MathObjectType &type, const MathObjectType &boundType) {
+    getMapMutable().emplace(type, boundType);
   }
 };
 
 }
 
 inline bool isBaseOf(const MathObjectType &toType, const MathObjectType &fromType) {
-  const auto &typeToTypeMap = detail::MathObjectBoundTypes::get();
+  const auto &typeToTypeMap = detail::MathObjectBoundTypes::getMap();
 
   if (const auto toTypeBoundaries = typeToTypeMap.find(toType); toTypeBoundaries != typeToTypeMap.end()) {
     return fromType >= toTypeBoundaries->first && fromType < toTypeBoundaries->second;

include/fintamath/core/MultiMethod.hpp

@@ -23,21 +23,21 @@ class MultiMethod<Res(ArgsBase...)> final {
 
   using Callback = std::function<Res(ArgsBase...)>;
 
-  using Callbacks = std::unordered_map<CallbackId, Callback, boost::hash<CallbackId>>;
+  using IdToCallbackMap = std::unordered_map<CallbackId, Callback, boost::hash<CallbackId>>;
 
 public:
   template <typename... Args>
     requires(sizeof...(Args) == sizeof...(ArgsBase))
   void add(const auto &func) {
-    callbacks[CallbackId(Args::getTypeStatic()...)] = [func](const ArgsBase &...args) {
+    idToCallbackMap[CallbackId(Args::getTypeStatic()...)] = [func](const ArgsBase &...args) {
       return func(cast<Args>(args)...);
     };
   }
 
   template <typename... Args>
     requires(sizeof...(Args) == sizeof...(ArgsBase))
   Res operator()(Args &&...args) const {
-    if (auto iter = callbacks.find(CallbackId(args.getType()...)); iter != callbacks.end()) {
+    if (auto iter = idToCallbackMap.find(CallbackId(args.getType()...)); iter != idToCallbackMap.end()) {
       return iter->second(std::forward<Args>(args)...);
     }
 
@@ -47,11 +47,11 @@ class MultiMethod<Res(ArgsBase...)> final {
   template <typename... Args>
     requires(sizeof...(Args) == sizeof...(ArgsBase))
   bool contains(const Args &...args) const {
-    return callbacks.contains(CallbackId(args.getType()...));
+    return idToCallbackMap.contains(CallbackId(args.getType()...));
   }
 
 private:
-  Callbacks callbacks;
+  IdToCallbackMap idToCallbackMap;
 };
 
 }

include/fintamath/core/Parser.hpp

@@ -33,7 +33,7 @@ class Parser<Return(Args...)> final {
 
   using ConstructorVector = std::vector<StringConstructor>;
 
-  using ConstructorMap = std::unordered_multimap<std::string, Constructor>;
+  using StringToConstructorMap = std::unordered_multimap<std::string, Constructor>;
 
 public:
   template <typename... ConstructorArgs>
@@ -46,8 +46,8 @@ class Parser<Return(Args...)> final {
   template <typename... ConstructorArgs>
     requires(SameAsUnqual<ConstructorArgs, Args> && ...)
   Return parse(const Validator &validator, const std::string &str, ConstructorArgs &&...args) const {
-    for (const auto &valuePairs = constructorMap.equal_range(str);
-         const auto &pair : stdv::iota(valuePairs.first, valuePairs.second)) {
+    for (const auto &pairs = stringToConstructorMap.equal_range(str);
+         const auto &pair : stdv::iota(pairs.first, pairs.second)) {
 
       if (Return value = pair->second(std::forward<ConstructorArgs>(args)...);
           value && validator(value)) {
@@ -81,7 +81,7 @@ class Parser<Return(Args...)> final {
     requires(!StringConstructable<Type, Args...>)
   void registerType(Constructor constructor) {
     static const std::string name = Type{}.toString();
-    constructorMap.emplace(name, std::move(constructor));
+    stringToConstructorMap.emplace(name, std::move(constructor));
 
     Tokenizer::registerToken(name);
   }
@@ -106,7 +106,7 @@ class Parser<Return(Args...)> final {
   }
 
 private:
-  ConstructorMap constructorMap;
+  StringToConstructorMap stringToConstructorMap;
 
   ConstructorVector extraConstructors;
 };

include/fintamath/functions/IFunction.hpp

@@ -16,7 +16,7 @@
 namespace fintamath {
 
 class IFunction : public IMathObject {
-  using FunctionOrderMap = std::unordered_map<std::string, size_t>;
+  using FunctionNameToOrderMap = std::unordered_map<std::string, size_t>;
 
   using FunctionParser = detail::Parser<std::unique_ptr<IFunction>()>;
 
@@ -57,7 +57,7 @@ class IFunction : public IMathObject {
   static void registerType() {
     getParser().registerType<T>();
 
-    getFunctionOrderMutableMap()[T{}.toString()] = maxFunctionOrder;
+    getFunctionNameToOrderMutableMap()[T{}.toString()] = maxFunctionOrder;
     maxFunctionOrder++;
   }
 
@@ -70,10 +70,10 @@ class IFunction : public IMathObject {
 
   virtual void validateArgsSize(const ArgumentRefVector &argVect) const;
 
-  static const FunctionOrderMap &getFunctionOrderMap();
+  static const FunctionNameToOrderMap &getFunctionNameToOrderMap();
 
 private:
-  static FunctionOrderMap &getFunctionOrderMutableMap();
+  static FunctionNameToOrderMap &getFunctionNameToOrderMutableMap();
 
   static FunctionParser &getParser();
 

include/fintamath/functions/IFunctionCRTP.hpp

@@ -24,7 +24,7 @@ class IFunctionCRTP_ : public IFunction {
 
   size_t getFunctionOrder() const final {
     static const std::string funcStr = Derived{}.toString();
-    return getFunctionOrderMap().at(funcStr);
+    return getFunctionNameToOrderMap().at(funcStr);
   }
 
   bool doArgsMatch(const ArgumentRefVector &argVect) const override {

src/fintamath/expressions/binary/CompExpression.cpp

@@ -113,15 +113,15 @@ void CompExpression::markAsSolution() {
 }
 
 std::shared_ptr<IFunction> CompExpression::getOppositeFunction(const IFunction &function) {
-  static const std::unordered_map<std::string, std::shared_ptr<IFunction>> oppositeFunctions = {
+  static const std::unordered_map<std::string, std::shared_ptr<IFunction>> nameToOppositeFuncMap = {
       {Eqv{}.toString(), std::make_shared<Eqv>()},
       {Neqv{}.toString(), std::make_shared<Neqv>()},
       {More{}.toString(), std::make_shared<Less>()},
       {Less{}.toString(), std::make_shared<More>()},
       {MoreEqv{}.toString(), std::make_shared<LessEqv>()},
       {LessEqv{}.toString(), std::make_shared<MoreEqv>()},
   };
-  return oppositeFunctions.at(function.toString());
+  return nameToOppositeFuncMap.at(function.toString());
 }
 
 ArgumentPtr CompExpression::constSimplify(const IFunction &func, const ArgumentPtr &lhs, const ArgumentPtr &rhs) {

src/fintamath/expressions/binary/DerivativeExpression.cpp

@@ -57,7 +57,7 @@ namespace fintamath {
 
 using namespace detail;
 
-using DerivativeSimplifyMap = std::unordered_map<
+using NameToSimplifyFunctionMap = std::unordered_map<
     std::string,
     std::function<ArgumentPtr(const ArgumentPtrVector &children,
                               const std::shared_ptr<const Variable> &var)>>;
@@ -92,8 +92,8 @@ ArgumentPtr DerivativeExpression::derivativeSimplify(const IFunction & /*func*/,
 }
 
 ArgumentPtr DerivativeExpression::exprSimplify(const std::shared_ptr<const IExpression> &expr, const std::shared_ptr<const Variable> &var) {
-  static const DerivativeSimplifyMap derivativeSimplifyMap = [] {
-    static const DerivativeSimplifyMap map = {
+  static const NameToSimplifyFunctionMap nameToSimplifyFunctionMap = [] {
+    static const NameToSimplifyFunctionMap map = {
         {Add{}.toString(), &addSimplify},
         {Mul{}.toString(), &mulSimplify},
         {Div{}.toString(), &divSimplify},
@@ -127,8 +127,8 @@ ArgumentPtr DerivativeExpression::exprSimplify(const std::shared_ptr<const IExpr
     return map;
   }();
 
-  if (const auto iter = derivativeSimplifyMap.find(expr->getFunction()->toString());
-      iter != derivativeSimplifyMap.end()) {
+  if (const auto iter = nameToSimplifyFunctionMap.find(expr->getFunction()->toString());
+      iter != nameToSimplifyFunctionMap.end()) {
 
     return iter->second(expr->getChildren(), var);
   }

src/fintamath/expressions/unary/FloorCeilExpression.cpp

@@ -56,11 +56,11 @@ ArgumentPtr FloorCeilExpression::negSimplify(const IFunction &func, const Argume
 }
 
 std::shared_ptr<IFunction> FloorCeilExpression::getOppositeFunction(const IFunction &function) {
-  static const std::unordered_map<std::string, std::shared_ptr<IFunction>> oppositeFunctions = {
+  static const std::unordered_map<std::string, std::shared_ptr<IFunction>> nameToOppositeFuncMap = {
       {Floor{}.toString(), std::make_shared<Ceil>()},
       {Ceil{}.toString(), std::make_shared<Floor>()},
   };
-  return oppositeFunctions.at(function.toString());
+  return nameToOppositeFuncMap.at(function.toString());
 }
 
 }

src/fintamath/expressions/unary/HyperbExpression.cpp

@@ -31,7 +31,7 @@ namespace fintamath {
 
 using namespace detail;
 
-using SimplifyFunctionMap = std::unordered_map<std::string, std::function<ArgumentPtr(const ArgumentPtr &)>>;
+using NameToSimplifyFunctionMap = std::unordered_map<std::string, std::function<ArgumentPtr(const ArgumentPtr &)>>;
 
 HyperbExpression::HyperbExpression(const IFunction &inFunc, ArgumentPtr inChild)
     : IUnaryExpressionCRTP(inFunc, std::move(inChild)) {
@@ -66,7 +66,7 @@ ArgumentPtr HyperbExpression::oppositeFunctionsSimplify(const IFunction &func, c
 }
 
 ArgumentPtr HyperbExpression::expandSimplify(const IFunction &func, const ArgumentPtr &rhs) {
-  static const SimplifyFunctionMap expandFunctionMap = {
+  static const NameToSimplifyFunctionMap nameToExpandFunctionMap = {
       {Tanh{}.toString(),
        [](const ArgumentPtr &inRhs) {
          return divExpr(sinhExpr(inRhs), coshExpr(inRhs));
@@ -85,15 +85,15 @@ ArgumentPtr HyperbExpression::expandSimplify(const IFunction &func, const Argume
        }},
   };
 
-  if (const auto iter = expandFunctionMap.find(func.toString()); iter != expandFunctionMap.end()) {
+  if (const auto iter = nameToExpandFunctionMap.find(func.toString()); iter != nameToExpandFunctionMap.end()) {
     return iter->second(rhs);
   }
 
   return {};
 }
 
 ArgumentPtr HyperbExpression::negSimplify(const IFunction &func, const ArgumentPtr &rhs) {
-  static const SimplifyFunctionMap negFunctionsMap = {
+  static const NameToSimplifyFunctionMap nameToNegFunctionsMap = {
       {Sinh{}.toString(),
        [](const ArgumentPtr &inRhs) {
          return negExpr(sinhExpr(negExpr(inRhs)));
@@ -105,7 +105,7 @@ ArgumentPtr HyperbExpression::negSimplify(const IFunction &func, const ArgumentP
   };
 
   if (isNegated(rhs)) {
-    if (const auto iter = negFunctionsMap.find(func.toString()); iter != negFunctionsMap.end()) {
+    if (const auto iter = nameToNegFunctionsMap.find(func.toString()); iter != nameToNegFunctionsMap.end()) {
       return iter->second(rhs);
     }
   }
@@ -114,15 +114,15 @@ ArgumentPtr HyperbExpression::negSimplify(const IFunction &func, const ArgumentP
 }
 
 std::shared_ptr<IFunction> HyperbExpression::getOppositeFunction(const IFunction &function) {
-  static const std::unordered_map<std::string, std::shared_ptr<IFunction>> oppositeFunctions = {
+  static const std::unordered_map<std::string, std::shared_ptr<IFunction>> nameToOppositeFunctionMap = {
       {Sinh{}.toString(), std::make_unique<Asinh>()},
       {Cosh{}.toString(), std::make_unique<Acosh>()},
       {Tanh{}.toString(), std::make_unique<Atanh>()},
       {Coth{}.toString(), std::make_unique<Acoth>()},
       {Sech{}.toString(), std::make_shared<Asech>()},
       {Csch{}.toString(), std::make_shared<Acsch>()},
   };
-  return oppositeFunctions.at(function.toString());
+  return nameToOppositeFunctionMap.at(function.toString());
 }
 
 }