polyval operator

docs_input/api/polynomials/polyval.rst

@@ -0,0 +1,18 @@
+.. _polyval_func:
+
+polyval
+=======
+
+Evaluate a polynomial given an input sequence and coefficients
+
+.. doxygenfunction:: polyval(const Op &op, const Coeffs &coeffs)
+
+Examples
+~~~~~~~~
+
+.. literalinclude:: ../../../test/00_operators/OperatorTests.cu
+   :language: cpp
+   :start-after: example-begin polyval-test-1
+   :end-before: example-end polyval-test-1
+   :dedent:
+

include/matx/generators/meshgrid.h

@@ -40,7 +40,7 @@ namespace matx
   namespace detail {
 
     template <typename T1, int RANK, int AXIS> 
-      class MeshGridOp {
+      class MeshGridOp : public BaseOp<MeshGridOp<T1, RANK, AXIS>> {
         private:
           T1 t1_;
           std::array<index_t, RANK> shape_;
@@ -72,6 +72,22 @@ namespace matx
             return shape_[dim];
           }
 
+          template <typename ShapeType, typename Executor>
+          __MATX_INLINE__ void PreRun(ShapeType &&shape, Executor &&ex) const noexcept
+          {
+            if constexpr (is_matx_op<T1>()) {
+              t1_.PreRun(std::forward<ShapeType>(shape), std::forward<Executor>(ex));
+            }
+          }
+
+          template <typename ShapeType, typename Executor>
+          __MATX_INLINE__ void PostRun(ShapeType &&shape, Executor &&ex) const noexcept
+          {
+            if constexpr (is_matx_op<T1>()) {
+              t1_.PostRun(std::forward<ShapeType>(shape), std::forward<Executor>(ex));
+            }
+          }            
+
           static __MATX_INLINE__ constexpr __MATX_HOST__ __MATX_DEVICE__ int32_t Rank() { return RANK; }
       };
 

include/matx/operators/all.h

@@ -96,6 +96,14 @@ namespace detail {
         Exec(std::make_tuple(tmp_out_), std::forward<Executor>(ex));
       }
 
+        template <typename ShapeType, typename Executor>
+        __MATX_INLINE__ void PostRun([[maybe_unused]] ShapeType &&shape, [[maybe_unused]] Executor &&ex) const noexcept
+        {
+          if constexpr (is_matx_op<OpA>()) {
+            a_.PostRun(std::forward<ShapeType>(shape), std::forward<Executor>(ex));
+          }
+        }      
+
       constexpr __MATX_INLINE__ __MATX_HOST__ __MATX_DEVICE__ index_t Size(int dim) const
       {
         return out_dims_[dim];

include/matx/operators/ambgfun.h

@@ -127,6 +127,18 @@ namespace matx
 
           Exec(std::make_tuple(tmp_out_), std::forward<Executor>(ex));
         }
+
+        template <typename ShapeType, typename Executor>
+        __MATX_INLINE__ void PostRun(ShapeType &&shape, Executor &&ex) const noexcept
+        {
+          if constexpr (is_matx_op<OpX>()) {
+            x_.PostRun(std::forward<ShapeType>(shape), std::forward<Executor>(ex));
+          }
+
+          if constexpr (is_matx_op<OpY>()) {
+            y_.PostRun(std::forward<ShapeType>(shape), std::forward<Executor>(ex));
+          }
+        }            
     };
   }
 

include/matx/operators/any.h

@@ -96,6 +96,14 @@ namespace detail {
         Exec(std::make_tuple(tmp_out_), std::forward<Executor>(ex));
       }
 
+      template <typename ShapeType, typename Executor>
+      __MATX_INLINE__ void PostRun(ShapeType &&shape, Executor &&ex) const noexcept
+      {
+        if constexpr (is_matx_op<OpA>()) {
+          a_.PostRun(std::forward<ShapeType>(shape), std::forward<Executor>(ex));
+        }
+      }          
+
       constexpr __MATX_INLINE__ __MATX_HOST__ __MATX_DEVICE__ index_t Size(int dim) const
       {
         return out_dims_[dim];

include/matx/operators/cart2sph.h

@@ -92,6 +92,38 @@ namespace matx
 					index_t size3 = get_expanded_size<Rank()>(z_, dim);
 					return detail::matx_max(size1, size2, size3);  
         }
+
+        template <typename ShapeType, typename Executor>
+        __MATX_INLINE__ void PreRun([[maybe_unused]] ShapeType &&shape, Executor &&ex) const noexcept
+        {
+          if constexpr (is_matx_op<T1>()) {
+            x_.PreRun(std::forward<ShapeType>(shape), std::forward<Executor>(ex));
+          }
+
+          if constexpr (is_matx_op<T2>()) {
+            y_.PreRun(std::forward<ShapeType>(shape), std::forward<Executor>(ex));
+          }
+
+          if constexpr (is_matx_op<T3>()) {
+            z_.PreRun(std::forward<ShapeType>(shape), std::forward<Executor>(ex));
+          }
+        }
+
+        template <typename ShapeType, typename Executor>
+        __MATX_INLINE__ void PostRun(ShapeType &&shape, Executor &&ex) const noexcept
+        {
+          if constexpr (is_matx_op<T1>()) {
+            x_.PostRun(std::forward<ShapeType>(shape), std::forward<Executor>(ex));
+          }
+
+          if constexpr (is_matx_op<T2>()) {
+            y_.PostRun(std::forward<ShapeType>(shape), std::forward<Executor>(ex));
+          }
+
+          if constexpr (is_matx_op<T3>()) {
+            z_.PostRun(std::forward<ShapeType>(shape), std::forward<Executor>(ex));
+          }
+        }        
     };
   }
   /**

include/matx/operators/cast.h

@@ -81,6 +81,22 @@ namespace matx
           return static_cast<NewType>(op_(indices...));
         }
 
+        template <typename ShapeType, typename Executor>
+        __MATX_INLINE__ void PreRun(ShapeType &&shape, Executor &&ex) const noexcept
+        {
+          if constexpr (is_matx_op<T>()) {
+            op_.PreRun(std::forward<ShapeType>(shape), std::forward<Executor>(ex));
+          }
+        }
+
+        template <typename ShapeType, typename Executor>
+        __MATX_INLINE__ void PostRun(ShapeType &&shape, Executor &&ex) const noexcept
+        {
+          if constexpr (is_matx_op<T>()) {
+            op_.PostRun(std::forward<ShapeType>(shape), std::forward<Executor>(ex));
+          }
+        }            
+
         static __MATX_INLINE__ constexpr __MATX_HOST__ __MATX_DEVICE__ int32_t Rank()
         {
           return detail::get_rank<T>();

include/matx/operators/cgsolve.h

@@ -108,6 +108,18 @@ namespace matx
 
           Exec(std::make_tuple(tmp_out_), std::forward<Executor>(ex));
         }
+
+        template <typename ShapeType, typename Executor>
+        __MATX_INLINE__ void PostRun(ShapeType &&shape, Executor &&ex) const noexcept
+        {
+          if constexpr (is_matx_op<OpA>()) {
+            a_.PostRun(std::forward<ShapeType>(shape), std::forward<Executor>(ex));
+          }     
+
+          if constexpr (is_matx_op<OpB>()) {
+            b_.PostRun(std::forward<ShapeType>(shape), std::forward<Executor>(ex));
+          } 
+        }           
     };
   }
 

include/matx/operators/channelize_poly.h

@@ -106,6 +106,18 @@ namespace detail {
         Exec(std::make_tuple(tmp_out_), std::forward<Executor>(ex));
       }
 
+      template <typename ShapeType, typename Executor>
+      __MATX_INLINE__ void PostRun(ShapeType &&shape, Executor &&ex) const noexcept
+      {
+        if constexpr (is_matx_op<OpA>()) {
+          a_.PostRun(std::forward<ShapeType>(shape), std::forward<Executor>(ex));
+        }     
+
+        if constexpr (is_matx_op<FilterType>()) {
+          f_.PostRun(std::forward<ShapeType>(shape), std::forward<Executor>(ex));
+        } 
+      }        
+
       constexpr __MATX_INLINE__ __MATX_HOST__ __MATX_DEVICE__ index_t Size(int dim) const
       {
         return out_dims_[dim];

include/matx/operators/chol.h

@@ -89,6 +89,14 @@ namespace detail {
         Exec(std::make_tuple(tmp_out_), std::forward<Executor>(ex));
       }
 
+      template <typename ShapeType, typename Executor>
+      __MATX_INLINE__ void PostRun(ShapeType &&shape, Executor &&ex) const noexcept
+      {
+        if constexpr (is_matx_op<OpA>()) {
+          a_.PostRun(std::forward<ShapeType>(shape), std::forward<Executor>(ex));
+        }
+      }        
+
       // Size is not relevant in eig() since there are multiple return values and it
       // is not allowed to be called in larger expressions
       constexpr __MATX_INLINE__ __MATX_HOST__ __MATX_DEVICE__ index_t Size(int dim) const

include/matx/operators/corr.h

@@ -162,6 +162,19 @@ namespace matx
 
           Exec(std::make_tuple(tmp_out_), std::forward<Executor>(ex));
         }
+
+        template <typename ShapeType, typename Executor>
+        __MATX_INLINE__ void PostRun(ShapeType &&shape, Executor &&ex) const noexcept
+        {
+          if constexpr (is_matx_op<OpA>()) {
+            a_.PostRun(std::forward<ShapeType>(shape), std::forward<Executor>(ex));
+          }
+
+
+          if constexpr (is_matx_op<OpB>()) {
+            b_.PostRun(std::forward<ShapeType>(shape), std::forward<Executor>(ex));
+          }          
+        }          
     };
   }
 

include/matx/operators/cov.h

@@ -100,6 +100,14 @@ namespace matx
 
           Exec(std::make_tuple(tmp_out_), std::forward<Executor>(ex));
         }
+
+        template <typename ShapeType, typename Executor>
+        __MATX_INLINE__ void PostRun(ShapeType &&shape, Executor &&ex) const noexcept
+        {
+          if constexpr (is_matx_op<OpA>()) {
+            a_.PostRun(std::forward<ShapeType>(shape), std::forward<Executor>(ex));
+          }
+        }          
     };
   }
 

include/matx/operators/cumsum.h

@@ -92,6 +92,14 @@ namespace detail {
         Exec(std::make_tuple(tmp_out_), std::forward<Executor>(ex));
       }
 
+      template <typename ShapeType, typename Executor>
+      __MATX_INLINE__ void PostRun(ShapeType &&shape, Executor &&ex) const noexcept
+      {
+        if constexpr (is_matx_op<OpA>()) {
+          a_.PostRun(std::forward<ShapeType>(shape), std::forward<Executor>(ex));
+        }
+      }        
+
       constexpr __MATX_INLINE__ __MATX_HOST__ __MATX_DEVICE__ index_t Size(int dim) const
       {
         return out_dims_[dim];

include/matx/operators/det.h

@@ -88,6 +88,14 @@ namespace detail {
         Exec(std::make_tuple(tmp_out_), std::forward<Executor>(ex));
       }
 
+      template <typename ShapeType, typename Executor>
+      __MATX_INLINE__ void PostRun(ShapeType &&shape, Executor &&ex) const noexcept
+      {
+        if constexpr (is_matx_op<OpA>()) {
+          a_.PostRun(std::forward<ShapeType>(shape), std::forward<Executor>(ex));
+        }
+      }        
+
       // Size is not relevant in det() since there are multiple return values and it
       // is not allowed to be called in larger expressions
       constexpr __MATX_INLINE__ __MATX_HOST__ __MATX_DEVICE__ index_t Size(int dim) const

include/matx/operators/fft.h

@@ -171,6 +171,14 @@ namespace matx
 
           Exec(std::make_tuple(tmp_out_), std::forward<Executor>(ex));
         }
+
+        template <typename ShapeType, typename Executor>
+        __MATX_INLINE__ void PostRun(ShapeType &&shape, Executor &&ex) const noexcept
+        {
+          if constexpr (is_matx_op<OpA>()) {
+            a_.PostRun(std::forward<ShapeType>(shape), std::forward<Executor>(ex));
+          }
+        }          
     };
   }
 

include/matx/operators/filter.h

@@ -99,6 +99,14 @@ namespace detail {
 
         Exec(std::make_tuple(tmp_out_), std::forward<Executor>(ex));
       }
+
+      template <typename ShapeType, typename Executor>
+      __MATX_INLINE__ void PostRun(ShapeType &&shape, Executor &&ex) const noexcept
+      {
+        if constexpr (is_matx_op<OpA>()) {
+          a_.PostRun(std::forward<ShapeType>(shape), std::forward<Executor>(ex));
+        }
+      }        
 
       constexpr __MATX_INLINE__ __MATX_HOST__ __MATX_DEVICE__ index_t Size(int dim) const
       {

include/matx/operators/flatten.h

@@ -85,6 +85,22 @@ namespace matx
 
           return size;
         }
+
+        template <typename ShapeType, typename Executor>
+        __MATX_INLINE__ void PreRun(ShapeType &&shape, Executor &&ex) const noexcept
+        {
+          if constexpr (is_matx_op<T1>()) {
+            op1_.PreRun(std::forward<ShapeType>(shape), std::forward<Executor>(ex));
+          }
+        }
+
+        template <typename ShapeType, typename Executor>
+        __MATX_INLINE__ void PostRun(ShapeType &&shape, Executor &&ex) const noexcept
+        {
+          if constexpr (is_matx_op<T1>()) {
+            op1_.PostRun(std::forward<ShapeType>(shape), std::forward<Executor>(ex));
+          }
+        }          
     };
   }
 

include/matx/operators/hermitian.h

@@ -79,6 +79,22 @@ namespace matx
           // Optimize these branches later
           return (dim < (Rank() - 2)) ? op_.Size(dim) : op_.Size((dim == Rank() - 1) ? Rank() - 2 : Rank() - 1);
         }
+
+        template <typename ShapeType, typename Executor>
+        __MATX_INLINE__ void PreRun(ShapeType &&shape, Executor &&ex) const noexcept
+        {
+          if constexpr (is_matx_op<T1>()) {
+            op_.PreRun(std::forward<ShapeType>(shape), std::forward<Executor>(ex));
+          }
+        }
+
+        template <typename ShapeType, typename Executor>
+        __MATX_INLINE__ void PostRun(ShapeType &&shape, Executor &&ex) const noexcept
+        {
+          if constexpr (is_matx_op<T1>()) {
+            op_.PostRun(std::forward<ShapeType>(shape), std::forward<Executor>(ex));
+          }
+        }          
     };
   }
 

include/matx/operators/hist.h

@@ -96,6 +96,14 @@ namespace detail {
         Exec(std::make_tuple(tmp_out_), std::forward<Executor>(ex));
       }
 
+      template <typename ShapeType, typename Executor>
+      __MATX_INLINE__ void PostRun(ShapeType &&shape, Executor &&ex) const noexcept
+      {
+        if constexpr (is_matx_op<OpA>()) {
+          a_.PostRun(std::forward<ShapeType>(shape), std::forward<Executor>(ex));
+        }
+      }        
+
       constexpr __MATX_INLINE__ __MATX_HOST__ __MATX_DEVICE__ index_t Size(int dim) const
       {
         return out_dims_[dim];