Add helpers for compile-time operator properties (#1114)

* Add helpers for compile-time operator properties

For some operators, we would like to extend or alter the default
behavior of the operator without modifying the operator's base API,
such as by adding new arguments or template parameters. Further,
for modifications known at compile time, we would prefer to avoid
increasing the size of the operators by storing additional metadata.

This PR adds helpers to allow the addition of compile-time properties
to operators. As an initial use case, the channelize_poly operator
now supports the following two properties:

  - PropAccum: Sets the accumulator type of the operator. This can be
    used to perform fp64 accumulation with fp32 inputs.
  - PropOutput: Directly set the output type (::value_type) of the
    operator. We typically deduce output types from the inputs and the
    context. For example, with a simple (a = b).run() usage, the type
    of the output a is known in the operator's Exec function. However,
    if we consider (a = b + c).run(), then if b is a transform, we will
    need to write its intermediate results to a temporary object and the
    type of that object will now depend on b's inputs. Using PropOutput,
    we can explicitly set the type of b's output, even for intermediates.

Currently, only the channelize_poly operator has been extended to support
properties. An example usage is as follows, from the ChannelizePoly.cu unit
tests:

```
    auto chan_poly = channelize_poly(ac32, f32, num_channels, decimation_factor)
      .props<PropAccum<double>, PropOutput<cuda::std::complex<double>>>();
```

Alternatively, the properties can be chained:

```
    auto chan_poly = channelize_poly(ac32, f32, num_channels, decimation_factor)
      .props<PropAccum<double>>()
      .props<PropOutput<cuda::std::complex<double>>>();

Above, we modify chan_poly to use fp64 accumulators and to have a double-precision
complex output type. With the single-precision inputs, the output type written
to temporary intermediates would have otherwise been single precision.

Signed-off-by: Thomas Benson <tbenson@nvidia.com>

* Move props support functions to matx::detail

Also fix other issues highlighted in PR feedback

* Address several PR comments

Signed-off-by: Thomas Benson <tbenson@nvidia.com>

* Add count property to prevent duplicate properties

Prevent duplicate properties like PropAccum<float> and
PropAccum<double>. That will now result in a static assertion
failure.

Signed-off-by: Thomas Benson <tbenson@nvidia.com>

* Fix channelize_poly copyright header

Signed-off-by: Thomas Benson <tbenson@nvidia.com>

---------

Signed-off-by: Thomas Benson <tbenson@nvidia.com>

Author: tbensonatl

docs_input/Doxyfile.in

@@ -2076,7 +2076,7 @@ SEARCH_INCLUDES        = YES
 # preprocessor.
 # This tag requires that the tag SEARCH_INCLUDES is set to YES.
 
-INCLUDE_PATH           =
+INCLUDE_PATH           = @PROJECT_SOURCE_DIR@/include
 
 # You can use the INCLUDE_FILE_PATTERNS tag to specify one or more wildcard
 # patterns (like *.h and *.hpp) to filter out the header-files in the

docs_input/api/signalimage/filtering/channelize_poly.rst

@@ -16,3 +16,9 @@ Examples
    :end-before: example-end channelize_poly-test-1
    :dedent:
 
+.. literalinclude:: ../../../../test/00_transform/ChannelizePoly.cu
+   :language: cpp
+   :start-after: example-begin channelize_poly-test-2
+   :end-before: example-end channelize_poly-test-2
+   :dedent:
+

include/matx/core/props.h

@@ -0,0 +1,186 @@
+////////////////////////////////////////////////////////////////////////////////
+// BSD 3-Clause License
+//
+// Copyright (c) 2026, NVIDIA Corporation
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+//
+// 1. Redistributions of source code must retain the above copyright notice, this
+//  list of conditions and the following disclaimer.
+//
+// 2. Redistributions in binary form must reproduce the above copyright notice,
+//  this list of conditions and the following disclaimer in the documentation
+//  and/or other materials provided with the distribution.
+//
+// 3. Neither the name of the copyright holder nor the names of its
+//  contributors may be used to endorse or promote products derived from
+//  this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+/////////////////////////////////////////////////////////////////////////////////
+
+#pragma once
+
+#include "matx/core/type_utils.h"
+#include <type_traits>
+#include <utility>
+
+namespace matx
+{
+namespace detail
+{
+
+template <typename... Ts>
+struct type_list {};
+
+// Check if a type is contained in a type_list
+template <typename T, typename List>
+struct contains;
+
+template <typename T>
+struct contains<T, type_list<>> : cuda::std::false_type {};
+
+template <typename T, typename Head, typename... Tail>
+struct contains<T, type_list<Head, Tail...>>
+    : cuda::std::conditional_t<cuda::std::is_same_v<T, Head>, cuda::std::true_type, contains<T, type_list<Tail...>>> {};
+
+// Helper to append a type if not already in the list
+template <typename List, typename T>
+struct append_unique;
+
+template <typename... Ts, typename T>
+struct append_unique<type_list<Ts...>, T> {
+    using type = cuda::std::conditional_t<
+        contains<T, type_list<Ts...>>::value,
+        type_list<Ts...>,           // already present -> keep list as is
+        type_list<Ts..., T>         // otherwise append
+    >;
+};
+
+// Recursively merge multiple types into a list
+template <typename List, typename... NewTs>
+struct merge_props_unique;
+
+template <typename List>
+struct merge_props_unique<List> { using type = List; };
+
+template <typename List, typename Head, typename... Tail>
+struct merge_props_unique<List, Head, Tail...> {
+    using type = typename merge_props_unique<
+        typename append_unique<List, Head>::type,
+        Tail...
+    >::type;
+};
+
+// Tag property
+template <typename T>
+struct prop_tag {};
+
+// Template category
+template <template <typename> class C>
+struct prop_category {};
+
+template <typename Spec, typename... Props>
+struct has_property;
+
+template <typename Tag, typename... Props>
+inline constexpr bool has_property_tag = (cuda::std::is_same_v<Tag, Props> || ...);
+
+template <template <typename> class C, typename T>
+struct is_property_category : cuda::std::false_type {};
+
+template <template <typename> class C, typename T>
+struct is_property_category<C, C<T>> : cuda::std::true_type {};
+
+template <template <typename> class C, typename... Props>
+inline constexpr bool has_property_category = (is_property_category<C, Props>::value || ...);
+
+template <template <typename> class Prop, typename... Props>
+struct count_property;
+
+template <template <typename> class Prop>
+struct count_property<Prop> : cuda::std::integral_constant<int, 0> {};
+
+template <template <typename> class Prop,
+          typename T,
+          typename... Tail>
+struct count_property<Prop, Prop<T>, Tail...>
+    : cuda::std::integral_constant<
+          int,
+          1 + count_property<Prop, Tail...>::value> {};
+
+template <template <typename> class Prop,
+          typename Head,
+          typename... Tail>
+struct count_property<Prop, Head, Tail...>
+    : count_property<Prop, Tail...> {};
+
+// The get_property_or helpers are used to extract a type from a category-style
+// property (i.e., a templated property) or return a default type if the property
+// is not found. Using the PropAccum property as an example, we can extract the accumulator
+// type or use the default output_t as follows:
+//   using accum_type = get_property_or<PropAccum, output_t, CurrentProps...>::type;
+
+// Base case: no properties, use the default type
+template <template <typename> class Prop, typename Default, typename... Props>
+struct get_property_or {
+    using type = Default;
+};
+
+// Case 1: Head matches Prop<T>
+template <template <typename> class Prop,
+          typename Default,
+          typename T,
+          typename... Tail>
+struct get_property_or<Prop, Default, Prop<T>, Tail...> {
+    static_assert(
+        count_property<Prop, Tail...>::value == 0,
+        "Duplicate property detected"
+    );
+
+    using type = T;
+};
+
+// Case 2: Head is something else
+template <template <typename> class Prop,
+          typename Default,
+          typename Head,
+          typename... Tail>
+struct get_property_or<Prop, Default, Head, Tail...> {
+    using type = typename get_property_or<Prop, Default, Tail...>::type;
+};
+
+} // namespace detail
+
+// Below are common properties meant to be reused by multiple operators. If a property only
+// makes sense for a single operator (such as a tag specificying a specific algorithm), then
+// the property should be defined directly in the operator.
+
+// PropAccum is a property to set the type of an accumulator. This should be used for operations
+// where a single accumulation type is sufficient. For operations where this type would be
+// ambiguous (e.g., those requiring multiple accumulators), more fine-grained properties
+// could be added.
+template <typename T>
+struct PropAccum { using type = T; };
+
+// PropOutput is a property to set the output type of an operator. By default, output types of
+// operators are deduced at compile time based on the input types and other operator properties.
+// The PropOutput property can be used to override the default output type. This can be useful,
+// for example, when an operator has single-precision inputs, but the user wishes to override
+// the accumulator type to double precision and avoid any implicit conversions to single
+// precision when writing the outputs.
+template <typename T>
+struct PropOutput { using type = T; };
+
+} // namespace matx