/*************************************************************************************************** * Copyright (c) 2023 - 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved. * SPDX-License-Identifier: BSD-3-Clause * * 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 // CUTE_HOST_DEVICE #include // cute::false_type, cute::true_type #include // cute::signum #include // __CUTE_REQUIRES namespace cute { /** Compile-time rational arithmetic type. * Like cute::C for std::integral_constant, cute::R for std::ratio has a short name * for error messages and compile times. * The static data members @a num and @a den represent the reduced numerator and denominator * of the rational value. Thus, two cute::R types with different @a n or @a d are distinct types * even if they represent the same rational value. * A cute::R exposes the reduced canonical type via its ::type member. * That is, cute::R<3,6>::type is cute::R<1,2> and cute::R<6,3>::type is cute::C<2>. * A cute::R::value can be used much like any other trait::value. It can be involved in * arithmetic expressions (according to the operator-overloads for cute::C and cute::R, * though these may be incomplete) but with a potential rational value rather than an integral value. */ template class R { static_assert(d != 0); static constexpr auto an = abs(n); static constexpr auto ad = abs(d); static constexpr auto g = gcd(an, ad); public: static constexpr auto num = signum(n) * signum(d) * an / g; static constexpr auto den = ad / g; // RI: den >= 1 && gcd(abs(num),den) == 1 using type = typename conditional, R>::type; }; template struct is_ratio : false_type {}; template struct is_ratio> : true_type {}; template CUTE_HOST_DEVICE constexpr typename R::type ratio(C, C) { return {}; } template CUTE_HOST_DEVICE constexpr typename R::type ratio(C, R) { return {}; } template CUTE_HOST_DEVICE constexpr typename R::type ratio(R, C ) { return {}; } template CUTE_HOST_DEVICE constexpr typename R::type ratio(R, R) { return {}; } // // Non-reduced ratio implementations // template CUTE_HOST_DEVICE constexpr R nratio(C , C) { return {}; } template CUTE_HOST_DEVICE constexpr R nratio(C, R) { return {}; } template CUTE_HOST_DEVICE constexpr R nratio(R, C ) { return {}; } template CUTE_HOST_DEVICE constexpr R nratio(R, R) { return {}; } // // Operators // template CUTE_HOST_DEVICE constexpr typename R::type operator*(R, R) { return {}; } template CUTE_HOST_DEVICE constexpr typename R::type operator*(R, C) { return {}; } template CUTE_HOST_DEVICE constexpr typename R::type operator*(C, R) { return {}; } // Product with dynamic type needs to produce an integer... template ::value)> CUTE_HOST_DEVICE constexpr auto operator*(C const& c, R) { return c * R::num / R::den; } // Product with dynamic type needs to produce an integer... template ::value)> CUTE_HOST_DEVICE constexpr auto operator*(R, C const& c) { return c * R::num / R::den; } template CUTE_HOST_DEVICE constexpr auto operator/(C const& c, R) { return c * R{}; } template CUTE_HOST_DEVICE constexpr typename R::type operator+(R, R) { return {}; } template CUTE_HOST_DEVICE constexpr typename R::type operator+(R, C) { return {}; } template CUTE_HOST_DEVICE constexpr typename R::type operator+(C, R) { return {}; } ///////////////// // Comparisons // ///////////////// template CUTE_HOST_DEVICE constexpr bool_constant::num == R::num && R::den == R::den> operator==(R, R) { return {}; } template CUTE_HOST_DEVICE constexpr bool_constant::num == c && R::den == 1> operator==(R, C) { return {}; } template CUTE_HOST_DEVICE constexpr bool_constant::num == c && R::den == 1> operator==(C, R) { return {}; } template CUTE_HOST_DEVICE constexpr bool_constant::num * R::den < R::num * R::den> operator<(R, R) { return {}; } template CUTE_HOST_DEVICE constexpr bool_constant::num < c * R::den> operator<(R, C) { return {}; } template CUTE_HOST_DEVICE constexpr bool_constant::den < R::num> operator<(C, R) { return {}; } /////////////////////// // Special functions // /////////////////////// template CUTE_HOST_DEVICE constexpr typename R::type gcd(R, R) { return {}; } template CUTE_HOST_DEVICE constexpr typename R::type gcd(R, C) { return {}; } template CUTE_HOST_DEVICE constexpr typename R::type gcd(C, R) { return {}; } template CUTE_HOST_DEVICE constexpr typename R::type abs(R) { return {}; } template CUTE_HOST_DEVICE constexpr int32_t log_2(R) { static_assert(R::num > 0); static_assert(R::den > 0); return log_2(static_cast(R::num)) - log_2(static_cast(R::den)); } // @return A non-reduced ratio cute::R of the Trait0::value / Trait1::value template CUTE_HOST_DEVICE constexpr auto trait_ratio(Trait0, Trait1) { return nratio(static_value(), static_value()); } // // Display utilities // template CUTE_HOST_DEVICE void print(R) { print(C {}); print("/"); print(C{}); } #if !defined(__CUDACC_RTC__) template CUTE_HOST std::ostream& operator<<(std::ostream& os, R) { return os << "_" << C{} << "/" << C{}; } #endif } // end namespace cute