Merge branch 'activationOperators' into addLogExpOperators

src/include/migraphx/auto_contiguous.hpp

-#ifndef MIGRAPH_GUARD_RTGLIB_AUTO_CONTIGOUS_HPP
-#define MIGRAPH_GUARD_RTGLIB_AUTO_CONTIGOUS_HPP
+#ifndef MIGRAPHX_GUARD_RTGLIB_AUTO_CONTIGOUS_HPP
+#define MIGRAPHX_GUARD_RTGLIB_AUTO_CONTIGOUS_HPP
 
 #include <string>
 #include <migraphx/instruction_ref.hpp>
 #include <migraphx/config.hpp>
 
 namespace migraphx {
-inline namespace MIGRAPH_INLINE_NS {
+inline namespace MIGRAPHX_INLINE_NS {
 
 struct program;
 
@@ -16,7 +16,7 @@ struct auto_contiguous
     void apply(program& p) const;
 };
 
-} // namespace MIGRAPH_INLINE_NS
+} // namespace MIGRAPHX_INLINE_NS
 } // namespace migraphx
 
 #endif

src/include/migraphx/builtin.hpp

-#ifndef MIGRAPH_GUARD_BUILTIN_HPP
-#define MIGRAPH_GUARD_BUILTIN_HPP
+#ifndef MIGRAPHX_GUARD_BUILTIN_HPP
+#define MIGRAPHX_GUARD_BUILTIN_HPP
 
 #include <migraphx/context.hpp>
 #include <migraphx/errors.hpp>
@@ -8,17 +8,17 @@
 #include <migraphx/config.hpp>
 
 namespace migraphx {
-inline namespace MIGRAPH_INLINE_NS {
+inline namespace MIGRAPHX_INLINE_NS {
 
 namespace builtin {
 
 struct literal
 {
     std::string name() const { return "@literal"; }
-    shape compute_shape(const std::vector<shape>&) const { MIGRAPH_THROW("builtin"); }
+    shape compute_shape(const std::vector<shape>&) const { MIGRAPHX_THROW("builtin"); }
     argument compute(context&, const shape&, const std::vector<argument>&) const
     {
-        MIGRAPH_THROW("builtin");
+        MIGRAPHX_THROW("builtin");
     }
 };
 
@@ -36,7 +36,7 @@ struct outline
     shape compute_shape(const std::vector<shape>&) const { return s; }
     argument compute(context&, const shape&, const std::vector<argument>&) const
     {
-        MIGRAPH_THROW("builtin");
+        MIGRAPHX_THROW("builtin");
     }
 };
 
@@ -51,10 +51,10 @@ struct param
     }
 
     std::string name() const { return "@param"; }
-    shape compute_shape(const std::vector<shape>&) const { MIGRAPH_THROW("builtin"); }
+    shape compute_shape(const std::vector<shape>&) const { MIGRAPHX_THROW("builtin"); }
     argument compute(context&, const shape&, const std::vector<argument>&) const
     {
-        MIGRAPH_THROW("builtin");
+        MIGRAPHX_THROW("builtin");
     }
     friend std::ostream& operator<<(std::ostream& os, const param& op)
     {
@@ -64,7 +64,7 @@ struct param
 };
 
 } // namespace builtin
-} // namespace MIGRAPH_INLINE_NS
+} // namespace MIGRAPHX_INLINE_NS
 } // namespace migraphx
 
 #endif

src/include/migraphx/check_context.hpp

-#ifndef MIGRAPH_GUARD_RTGLIB_CHECK_CONTEXT_HPP
-#define MIGRAPH_GUARD_RTGLIB_CHECK_CONTEXT_HPP
+#ifndef MIGRAPHX_GUARD_RTGLIB_CHECK_CONTEXT_HPP
+#define MIGRAPHX_GUARD_RTGLIB_CHECK_CONTEXT_HPP
 
 #include <migraphx/program.hpp>
 #include <migraphx/config.hpp>
 
 namespace migraphx {
-inline namespace MIGRAPH_INLINE_NS {
+inline namespace MIGRAPHX_INLINE_NS {
 
 template <class T>
 struct check_context
@@ -18,7 +18,7 @@ struct check_context
         {
             T* x = any_cast<T>(&ctx);
             if(x == nullptr)
-                MIGRAPH_THROW(std::string("Unexpected context type: ") + ctx.type_id().name());
+                MIGRAPHX_THROW(std::string("Unexpected context type: ") + ctx.type_id().name());
             return {};
         }
     };
@@ -27,7 +27,7 @@ struct check_context
     void apply(program& p) const { p.insert_instruction(p.begin(), op{}); }
 };
 
-} // namespace MIGRAPH_INLINE_NS
+} // namespace MIGRAPHX_INLINE_NS
 } // namespace migraphx
 
 #endif

src/include/migraphx/check_shapes.hpp

-#ifndef MIGRAPH_GUARD_RTGLIB_CHECK_SHAPES_HPP
-#define MIGRAPH_GUARD_RTGLIB_CHECK_SHAPES_HPP
+#ifndef MIGRAPHX_GUARD_RTGLIB_CHECK_SHAPES_HPP
+#define MIGRAPHX_GUARD_RTGLIB_CHECK_SHAPES_HPP
 
 #include <migraphx/shape.hpp>
 #include <migraphx/config.hpp>
 #include <algorithm>
 
 namespace migraphx {
-inline namespace MIGRAPH_INLINE_NS {
+inline namespace MIGRAPHX_INLINE_NS {
 
 struct check_shapes
 {
@@ -46,8 +46,8 @@ struct check_shapes
     const check_shapes& has(std::size_t n) const
     {
         if(size() != n)
-            MIGRAPH_THROW(prefix() + "Wrong number of arguments: expected " + std::to_string(n) +
-                          " but given " + std::to_string(size()));
+            MIGRAPHX_THROW(prefix() + "Wrong number of arguments: expected " + std::to_string(n) +
+                           " but given " + std::to_string(size()));
         return *this;
     }
 
@@ -58,7 +58,7 @@ struct check_shapes
         if(begin != end)
         {
             if(begin->lens().size() != n)
-                MIGRAPH_THROW(prefix() + "Only " + std::to_string(n) + "d supported");
+                MIGRAPHX_THROW(prefix() + "Only " + std::to_string(n) + "d supported");
         }
         return *this;
     }
@@ -66,56 +66,56 @@ struct check_shapes
     const check_shapes& same_shape() const
     {
         if(!this->same([](const shape& s) { return s; }))
-            MIGRAPH_THROW(prefix() + "Shapes do not match");
+            MIGRAPHX_THROW(prefix() + "Shapes do not match");
         return *this;
     }
 
     const check_shapes& same_type() const
     {
         if(!this->same([](const shape& s) { return s.type(); }))
-            MIGRAPH_THROW(prefix() + "Types do not match");
+            MIGRAPHX_THROW(prefix() + "Types do not match");
         return *this;
     }
 
     const check_shapes& same_dims() const
     {
         if(!this->same([](const shape& s) { return s.lens(); }))
-            MIGRAPH_THROW(prefix() + "Dimensions do not match");
+            MIGRAPHX_THROW(prefix() + "Dimensions do not match");
         return *this;
     }
 
     const check_shapes& same_ndims() const
     {
         if(!this->same([](const shape& s) { return s.lens().size(); }))
-            MIGRAPH_THROW(prefix() + "Number of dimensions do not match");
+            MIGRAPHX_THROW(prefix() + "Number of dimensions do not match");
         return *this;
     }
 
     const check_shapes& standard() const
     {
         if(!this->all_of([](const shape& s) { return s.standard(); }))
-            MIGRAPH_THROW(prefix() + "Shapes are not in standard layout");
+            MIGRAPHX_THROW(prefix() + "Shapes are not in standard layout");
         return *this;
     }
 
     const check_shapes& packed() const
     {
         if(!this->all_of([](const shape& s) { return s.packed(); }))
-            MIGRAPH_THROW(prefix() + "Shapes are not packed");
+            MIGRAPHX_THROW(prefix() + "Shapes are not packed");
         return *this;
     }
 
     const check_shapes& not_transposed() const
     {
         if(!this->all_of([](const shape& s) { return not s.transposed(); }))
-            MIGRAPH_THROW(prefix() + "Shapes are transposed");
+            MIGRAPHX_THROW(prefix() + "Shapes are transposed");
         return *this;
     }
 
     const check_shapes& not_broadcasted() const
     {
         if(!this->all_of([](const shape& s) { return not s.broadcasted(); }))
-            MIGRAPH_THROW(prefix() + "Shapes are broadcasted");
+            MIGRAPHX_THROW(prefix() + "Shapes are broadcasted");
         return *this;
     }
 
@@ -143,7 +143,7 @@ struct check_shapes
     const shape* get(long i)
     {
         if(i >= size())
-            MIGRAPH_THROW(prefix() + "Accessing shape out of bounds");
+            MIGRAPHX_THROW(prefix() + "Accessing shape out of bounds");
         assert(begin != nullptr);
         assert(end != nullptr);
         if(i < 0)
@@ -156,7 +156,7 @@ struct check_shapes
     check_shapes slice(long start, long last) { return {get(start), get(last), name}; }
 };
 
-} // namespace MIGRAPH_INLINE_NS
+} // namespace MIGRAPHX_INLINE_NS
 } // namespace migraphx
 
 #endif

src/include/migraphx/common_subexpression_elimination.hpp

-#ifndef MIGRAPH_GUARD_RTGLIB_COMMON_SUBEXPRESSION_ELIMINATION_HPP
-#define MIGRAPH_GUARD_RTGLIB_COMMON_SUBEXPRESSION_ELIMINATION_HPP
+#ifndef MIGRAPHX_GUARD_RTGLIB_COMMON_SUBEXPRESSION_ELIMINATION_HPP
+#define MIGRAPHX_GUARD_RTGLIB_COMMON_SUBEXPRESSION_ELIMINATION_HPP
 
 #include <string>
 #include <migraphx/instruction_ref.hpp>
 #include <migraphx/config.hpp>
 
 namespace migraphx {
-inline namespace MIGRAPH_INLINE_NS {
+inline namespace MIGRAPHX_INLINE_NS {
 
 struct program;
 
@@ -19,7 +19,7 @@ struct common_subexpression_elimination
     void apply(program& p) const;
 };
 
-} // namespace MIGRAPH_INLINE_NS
+} // namespace MIGRAPHX_INLINE_NS
 } // namespace migraphx
 
 #endif

src/include/migraphx/concat_opt.hpp

-#ifndef MIGRAPH_GUARD_CONCAT_OPT_HPP
-#define MIGRAPH_GUARD_CONCAT_OPT_HPP
+#ifndef MIGRAPHX_GUARD_CONCAT_OPT_HPP
+#define MIGRAPHX_GUARD_CONCAT_OPT_HPP
 
 #include <cassert>
 #include <string>
@@ -13,7 +13,7 @@
 #include <migraphx/config.hpp>
 
 namespace migraphx {
-inline namespace MIGRAPH_INLINE_NS {
+inline namespace MIGRAPHX_INLINE_NS {
 
 struct program;
 
@@ -235,7 +235,7 @@ inline const ValueType& any_cast(const concat_optimization& x)
 }
 
 #endif
-} // namespace MIGRAPH_INLINE_NS
+} // namespace MIGRAPHX_INLINE_NS
 } // namespace migraphx
 
 #endif

src/include/migraphx/config.hpp

-#ifndef MIGRAPH_GUARD_CONFIG_HPP
-#define MIGRAPH_GUARD_CONFIG_HPP
+#ifndef MIGRAPHX_GUARD_CONFIG_HPP
+#define MIGRAPHX_GUARD_CONFIG_HPP
 
 namespace migraphx {
 
-#if !defined(MIGRAPH_USE_CLANG_TIDY) && !defined(DOXYGEN)
-#define MIGRAPH_INLINE_NS version_1
+#if !defined(MIGRAPHX_USE_CLANG_TIDY) && !defined(DOXYGEN)
+#define MIGRAPHX_INLINE_NS version_1
 #endif
 
 } // namespace migraphx

src/include/migraphx/constant_propagate.hpp

-#ifndef MIGRAPH_GUARD_RTGLIB_CONSTANT_PROPAGATE_HPP
-#define MIGRAPH_GUARD_RTGLIB_CONSTANT_PROPAGATE_HPP
+#ifndef MIGRAPHX_GUARD_RTGLIB_CONSTANT_PROPAGATE_HPP
+#define MIGRAPHX_GUARD_RTGLIB_CONSTANT_PROPAGATE_HPP
 
 #include <string>
 #include <migraphx/config.hpp>
 
 namespace migraphx {
-inline namespace MIGRAPH_INLINE_NS {
+inline namespace MIGRAPHX_INLINE_NS {
 
 struct program;
 
@@ -18,7 +18,7 @@ struct constant_propagate
     void apply(program& p) const;
 };
 
-} // namespace MIGRAPH_INLINE_NS
+} // namespace MIGRAPHX_INLINE_NS
 } // namespace migraphx
 
 #endif

src/include/migraphx/context.hpp

-#ifndef MIGRAPH_GUARD_CONTEXT_HPP
-#define MIGRAPH_GUARD_CONTEXT_HPP
+#ifndef MIGRAPHX_GUARD_CONTEXT_HPP
+#define MIGRAPHX_GUARD_CONTEXT_HPP
 
 #include <cassert>
 #include <string>
@@ -10,7 +10,7 @@
 #include <migraphx/config.hpp>
 
 namespace migraphx {
-inline namespace MIGRAPH_INLINE_NS {
+inline namespace MIGRAPHX_INLINE_NS {
 
 #ifdef DOXYGEN
 
@@ -205,7 +205,7 @@ inline const ValueType& any_cast(const context& x)
 
 #endif
 
-} // namespace MIGRAPH_INLINE_NS
+} // namespace MIGRAPHX_INLINE_NS
 } // namespace migraphx
 
 #endif

src/include/migraphx/dead_code_elimination.hpp

-#ifndef MIGRAPH_GUARD_RTGLIB_DEAD_CODE_ELIMINATION_HPP
-#define MIGRAPH_GUARD_RTGLIB_DEAD_CODE_ELIMINATION_HPP
+#ifndef MIGRAPHX_GUARD_RTGLIB_DEAD_CODE_ELIMINATION_HPP
+#define MIGRAPHX_GUARD_RTGLIB_DEAD_CODE_ELIMINATION_HPP
 
 #include <string>
 #include <migraphx/instruction_ref.hpp>
 #include <migraphx/config.hpp>
 
 namespace migraphx {
-inline namespace MIGRAPH_INLINE_NS {
+inline namespace MIGRAPHX_INLINE_NS {
 
 struct program;
 
@@ -19,7 +19,7 @@ struct dead_code_elimination
     void apply(program& p) const;
 };
 
-} // namespace MIGRAPH_INLINE_NS
+} // namespace MIGRAPHX_INLINE_NS
 } // namespace migraphx
 
 #endif

src/include/migraphx/dfor.hpp

-#ifndef MIGRAPH_GUARD_MIGRAPHLIB_DFOR_HPP
-#define MIGRAPH_GUARD_MIGRAPHLIB_DFOR_HPP
+#ifndef MIGRAPHX_GUARD_MIGRAPHLIB_DFOR_HPP
+#define MIGRAPHX_GUARD_MIGRAPHLIB_DFOR_HPP
 
 #include <migraphx/config.hpp>
 
 namespace migraphx {
-inline namespace MIGRAPH_INLINE_NS {
+inline namespace MIGRAPHX_INLINE_NS {
 
 // Multidimensional for loop
 inline auto dfor()
@@ -23,7 +23,7 @@ auto dfor(T x, Ts... xs)
     };
 }
 
-} // namespace MIGRAPH_INLINE_NS
+} // namespace MIGRAPHX_INLINE_NS
 } // namespace migraphx
 
 #endif

src/include/migraphx/eliminate_allocation.hpp

-#ifndef MIGRAPH_GUARD_RTGLIB_ELIMINATE_ALLOCATION_HPP
-#define MIGRAPH_GUARD_RTGLIB_ELIMINATE_ALLOCATION_HPP
+#ifndef MIGRAPHX_GUARD_RTGLIB_ELIMINATE_ALLOCATION_HPP
+#define MIGRAPHX_GUARD_RTGLIB_ELIMINATE_ALLOCATION_HPP
 
 #include <string>
 #include <migraphx/instruction_ref.hpp>
 #include <migraphx/config.hpp>
 
 namespace migraphx {
-inline namespace MIGRAPH_INLINE_NS {
+inline namespace MIGRAPHX_INLINE_NS {
 
 struct program;
 
@@ -22,7 +22,7 @@ struct eliminate_allocation
     void apply(program& p) const;
 };
 
-} // namespace MIGRAPH_INLINE_NS
+} // namespace MIGRAPHX_INLINE_NS
 } // namespace migraphx
 
 #endif

src/include/migraphx/eliminate_concat.hpp

-#ifndef MIGRAPH_GUARD_RTGLIB_ELIMINATE_CONCAT_HPP
-#define MIGRAPH_GUARD_RTGLIB_ELIMINATE_CONCAT_HPP
+#ifndef MIGRAPHX_GUARD_RTGLIB_ELIMINATE_CONCAT_HPP
+#define MIGRAPHX_GUARD_RTGLIB_ELIMINATE_CONCAT_HPP
 
 #include <string>
 #include <migraphx/instruction_ref.hpp>
@@ -7,7 +7,7 @@
 #include <migraphx/config.hpp>
 
 namespace migraphx {
-inline namespace MIGRAPH_INLINE_NS {
+inline namespace MIGRAPHX_INLINE_NS {
 
 struct program;
 
@@ -21,7 +21,7 @@ struct eliminate_concat
     void apply(program& p) const;
 };
 
-} // namespace MIGRAPH_INLINE_NS
+} // namespace MIGRAPHX_INLINE_NS
 } // namespace migraphx
 
 #endif

src/include/migraphx/eliminate_contiguous.hpp

-#ifndef MIGRAPH_GUARD_RTGLIB_ELIMINATE_CONTIGUOUS_HPP
-#define MIGRAPH_GUARD_RTGLIB_ELIMINATE_CONTIGUOUS_HPP
+#ifndef MIGRAPHX_GUARD_RTGLIB_ELIMINATE_CONTIGUOUS_HPP
+#define MIGRAPHX_GUARD_RTGLIB_ELIMINATE_CONTIGUOUS_HPP
 
 #include <string>
 #include <migraphx/instruction_ref.hpp>
 #include <migraphx/config.hpp>
 
 namespace migraphx {
-inline namespace MIGRAPH_INLINE_NS {
+inline namespace MIGRAPHX_INLINE_NS {
 
 struct program;
 
@@ -19,7 +19,7 @@ struct eliminate_contiguous
     void apply(program& p) const;
 };
 
-} // namespace MIGRAPH_INLINE_NS
+} // namespace MIGRAPHX_INLINE_NS
 } // namespace migraphx
 
 #endif

src/include/migraphx/env.hpp

-#ifndef MIGRAPH_GUARD_RTGLIB_ENV_HPP
-#define MIGRAPH_GUARD_RTGLIB_ENV_HPP
+#ifndef MIGRAPHX_GUARD_RTGLIB_ENV_HPP
+#define MIGRAPHX_GUARD_RTGLIB_ENV_HPP
 
 #include <vector>
 #include <string>
 #include <migraphx/config.hpp>
 
 namespace migraphx {
-inline namespace MIGRAPH_INLINE_NS {
+inline namespace MIGRAPHX_INLINE_NS {
 
 // Declare a cached environment variable
-#define MIGRAPH_DECLARE_ENV_VAR(x)                \
+#define MIGRAPHX_DECLARE_ENV_VAR(x)               \
     struct x                                      \
     {                                             \
         static const char* value() { return #x; } \
@@ -33,7 +33,7 @@ bool disabled(T)
     return result;
 }
 
-} // namespace MIGRAPH_INLINE_NS
+} // namespace MIGRAPHX_INLINE_NS
 } // namespace migraphx
 
 #endif

src/include/migraphx/erase.hpp

-#ifndef MIGRAPH_GUARD_ERASE_HPP
-#define MIGRAPH_GUARD_ERASE_HPP
+#ifndef MIGRAPHX_GUARD_ERASE_HPP
+#define MIGRAPHX_GUARD_ERASE_HPP
 
 #include <algorithm>
 #include <migraphx/config.hpp>
 
 namespace migraphx {
-inline namespace MIGRAPH_INLINE_NS {
+inline namespace MIGRAPHX_INLINE_NS {
 
 /**
  * @brief Erase all elements from a container
@@ -33,7 +33,7 @@ auto erase_if(R&& r, P&& pred)
     return r.erase(std::remove_if(r.begin(), r.end(), pred), r.end());
 }
 
-} // namespace MIGRAPH_INLINE_NS
+} // namespace MIGRAPHX_INLINE_NS
 } // namespace migraphx
 
 #endif

src/include/migraphx/errors.hpp

-#ifndef MIGRAPH_GUARD_ERRORS_HPP
-#define MIGRAPH_GUARD_ERRORS_HPP
+#ifndef MIGRAPHX_GUARD_ERRORS_HPP
+#define MIGRAPHX_GUARD_ERRORS_HPP
 
 #include <exception>
 #include <stdexcept>
@@ -7,7 +7,7 @@
 #include <migraphx/config.hpp>
 
 namespace migraphx {
-inline namespace MIGRAPH_INLINE_NS {
+inline namespace MIGRAPHX_INLINE_NS {
 
 /// Represents exceptions that can be thrown by migraphxlib
 struct exception : std::runtime_error
@@ -43,10 +43,10 @@ inline std::string make_source_context(const std::string& file, int line)
 /**
  * @brief Throw an exception with context information
  */
-#define MIGRAPH_THROW(...) \
+#define MIGRAPHX_THROW(...) \
     throw migraphx::make_exception(migraphx::make_source_context(__FILE__, __LINE__), __VA_ARGS__)
 
-} // namespace MIGRAPH_INLINE_NS
+} // namespace MIGRAPHX_INLINE_NS
 } // namespace migraphx
 
 #endif

src/include/migraphx/fallthrough.hpp

-#ifndef MIGRAPH_GUARD_FALLTHROUGH_HPP
-#define MIGRAPH_GUARD_FALLTHROUGH_HPP
+#ifndef MIGRAPHX_GUARD_FALLTHROUGH_HPP
+#define MIGRAPHX_GUARD_FALLTHROUGH_HPP
 
 #include <migraphx/config.hpp>
 
 namespace migraphx {
-inline namespace MIGRAPH_INLINE_NS {
+inline namespace MIGRAPHX_INLINE_NS {
 
 #ifdef __clang__
-#define MIGRAPH_FALLTHROUGH [[clang::fallthrough]]
+#define MIGRAPHX_FALLTHROUGH [[clang::fallthrough]]
 #else
-#define MIGRAPH_FALLTHROUGH
+#define MIGRAPHX_FALLTHROUGH
 #endif
 
-} // namespace MIGRAPH_INLINE_NS
+} // namespace MIGRAPHX_INLINE_NS
 } // namespace migraphx
 
 #endif

src/include/migraphx/float_equal.hpp

-#ifndef MIGRAPH_GUARD_MIGRAPHLIB_FLOAT_EQUAL_HPP
-#define MIGRAPH_GUARD_MIGRAPHLIB_FLOAT_EQUAL_HPP
+#ifndef MIGRAPHX_GUARD_MIGRAPHLIB_FLOAT_EQUAL_HPP
+#define MIGRAPHX_GUARD_MIGRAPHLIB_FLOAT_EQUAL_HPP
 
 #include <algorithm>
 #include <cmath>
@@ -12,14 +12,14 @@
 #include <migraphx/config.hpp>
 
 namespace migraphx {
-inline namespace MIGRAPH_INLINE_NS {
+inline namespace MIGRAPHX_INLINE_NS {
 
 template <class... Ts>
 using common_type = typename std::common_type<Ts...>::type;
 
 struct float_equal_fn
 {
-    template <class T, MIGRAPH_REQUIRES(std::is_floating_point<T>{})>
+    template <class T, MIGRAPHX_REQUIRES(std::is_floating_point<T>{})>
     static bool apply(T x, T y)
     {
         return std::isfinite(x) and std::isfinite(y) and
@@ -27,7 +27,7 @@ struct float_equal_fn
                std::nextafter(x, std::numeric_limits<T>::max()) >= y;
     }
 
-    template <class T, MIGRAPH_REQUIRES(not std::is_floating_point<T>{})>
+    template <class T, MIGRAPHX_REQUIRES(not std::is_floating_point<T>{})>
     static bool apply(T x, T y)
     {
         return x == y;
@@ -42,7 +42,7 @@ struct float_equal_fn
 
 static constexpr float_equal_fn float_equal{};
 
-} // namespace MIGRAPH_INLINE_NS
+} // namespace MIGRAPHX_INLINE_NS
 } // namespace migraphx
 
 #endif

src/include/migraphx/functional.hpp

-#ifndef MIGRAPH_GUARD_RTGLIB_FUNCTIONAL_HPP
-#define MIGRAPH_GUARD_RTGLIB_FUNCTIONAL_HPP
+#ifndef MIGRAPHX_GUARD_RTGLIB_FUNCTIONAL_HPP
+#define MIGRAPHX_GUARD_RTGLIB_FUNCTIONAL_HPP
 
 #include <utility>
 #include <migraphx/config.hpp>
 
 namespace migraphx {
-inline namespace MIGRAPH_INLINE_NS {
+inline namespace MIGRAPHX_INLINE_NS {
 
 struct swallow
 {
@@ -131,7 +131,7 @@ auto fold(F f)
     return [=](auto&&... xs) { return fold_impl(f, std::forward<decltype(xs)>(xs)...); };
 }
 
-} // namespace MIGRAPH_INLINE_NS
+} // namespace MIGRAPHX_INLINE_NS
 } // namespace migraphx
 
 #endif