Added a specialization of ipow for signed integers.

The original signature of `ipow` only accepted an unsigned integer as exponent.
However, it seems that it was called using integers as exponents.
Thus there is now a specialization for this case.

For the sake of argument let's consider the following situation `ipow(a, b)`:
- If `b` was zero then the previous implementation would return `a`, the new implementation returns 1.
- If `b` was negative then it would perform a lot of iterations, because a signed integer was converted to an unsigned one.
	In the new implementation, the function would return 0, which is in agreement with what `pow` does.

dace/runtime/include/dace/math.h

@@ -589,6 +589,22 @@ namespace dace
             return result;
         }
 
+
+        template<
+            typename T,
+            typename U,
+            typename = std::enable_if_t<(std::is_integral<U>::value && std::is_signed<U>::value)>
+        >
+        DACE_CONSTEXPR DACE_HDFI T ipow(const T& a, const U b)
+        {
+            if(b < 0) {
+                return T(0);
+            };
+            using UnsignedU = std::make_unsigned_t<U>;
+            return ipow(a, UnsignedU{b});
+        }
+
+
         template<typename T, typename std::enable_if<std::is_integral<T>::value>::type* = nullptr>
         DACE_CONSTEXPR DACE_HDFI T ifloor(const T& a)
         {