Question

从数学，算法和元编程递归的角度来看，我有一个具有挑战性的问题。请考虑以下声明：

template<class R1, class R2>
using ratio_power = /* to be defined */;

基于std::ratio等std::ratio_add操作的示例。鉴于std::ratio R1和R2两个R1^R2 R1^R2和{{1}}此操作应该计算{{1}}当且仅当{{1}}是有理数时。如果它是不合理的，那么实现应该失败，就像当一个人尝试将两个非常大的比率相乘并且编译器说有一个整数溢出时。

三个问题：

你认为这是可能的，而不会爆炸编辑时间？
使用什么算法？
如何实施此操作？

Answer 1

此计算需要两个构建块：

编译时整数的n次幂
编译时整数的第n个根

注意：我使用int作为分子和分母的类型来保存一些打字，我希望主要的观点是。我从一个有效的实现中提取以下代码，但我不能保证我不会在某个地方写错字;）

第一个很容易：你使用x ^（2n）= x ^ n * x ^ n或x ^（2n + 1）= x ^ n * x ^ n * x 这样，您实例化最少的模板，例如x ^ 39计算如下： x39 = x19 * x19 * x x19 = x9 * x9 * x x9 = x4 * x4 * x x4 = x2 * x2 x2 = x1 * x1 x1 = x0 * x x0 = 1

template <int Base, int Exponent>
struct static_pow
{
  static const int temp = static_pow<Base, Exponent / 2>::value;
  static const int value = temp * temp * (Exponent % 2 == 1 ? Base : 1);
};

template <int Base>
struct static_pow<Base, 0>
{
  static const int value = 1;
};

第二个有点棘手，可以使用包围算法：给定x和N，我们想要找到一个数r，使得r ^ N = x

将包含解决方案的区间[低，高]设置为[1,1 + x / N]
计算中点均值=（低+高）/ 2
确定，如果平均值^ N> = x
- 如果是，请将间隔设置为[low，mean]
- 如果不是，请将间隔设置为[mean + 1，high]
如果间隔只包含一个数字，则计算完成
否则，再次迭代

该算法给出了最大整数s，其中s ^ N <= x

因此检查s ^ N == x。如果是，则x的第N个根是整数，否则不是。

现在让我们把它写成编译时程序：

基本界面：

template <int x, int N>
struct static_root : static_root_helper<x, N, 1, 1 + x / N> { };

助手：

template <int x, int N, int low, int high>
struct static_root_helper
{
  static const int mean = (low + high) / 2;
  static const bool is_left = calculate_left<mean, N, x>::value;
  static const int value = static_root_helper<x, N, (is_left ? low : mean + 1), (is_left ? mean, high)>::value;
};

递归的端点，其中间隔只包含一个条目：

template <int x, int N, int mid>
struct static_root_helper<x, N, mid, mid>
{
  static const int value = mid;
};

帮助检测乘法溢出（我认为你可以为c ++ 11 constexpr-numeric_limits交换boost-header）。如果乘法a * b溢出，则返回true。

#include "boost/integer_traits.hpp"

template <typename T, T a, T b>
struct mul_overflow
{
  static_assert(std::is_integral<T>::value, "T must be integral");
  static const bool value = (a > boost::integer_traits<T>::const_max / b);
};

现在我们需要实现calculate_left来计算x ^ N的解是平均值还是右边的。我们希望能够计算任意根，所以像static_pow＆gt;这样的天真实现。 x会很快溢出并给出错误的结果。因此我们使用以下方案：我们想要计算x ^ N是否>乙

设置A = x和i = 1
如果A＆gt; = B，我们已经完成了 - ＆gt; A ^ N肯定会大于B
会A * x溢出吗？
- 如果是 - > A ^ N肯定会大于B
- 如果不是 - ＆gt; A * = x和i + = 1
如果i == N，我们就完成了，我们可以对B

现在让我们把它写成元节目

template <int A, int N, int B>
struct calculate_left : calculate_left_helper<A, 1, A, N, B, (A >= B)> { };

template <int x, int i, int A, int N, int B, bool short_circuit>
struct calulate_left_helper
{
  static const bool overflow = mul_overflow<int, x, A>::value;
  static const int next = calculate_next<x, A, overflow>::value;
  static const bool value = calculate_left_helper<next, i + 1, A, N, B, (overflow || next >= B)>::value;
};

端点，其中i == N

template <int x, int A, int N, int B, bool short_circuit>
struct calculate_left_helper<x, N, A, N, B, short_circuit>
{
  static const bool value = (x >= B);
};

短路端点

template <int x, int i, int A, int N, int B>
struct calculate_down_helper<x, i, A, N, B, true>
{
  static const bool value = true;
};

template <int x, int A, int N, int B>
struct calculate_down_helper<x, N, A, N, B, true>
{
  static const bool value = true;
};

帮助器计算x * A的下一个值，考虑takex overflow以消除编译器警告：

template <int a, int b, bool overflow>
struct calculate_next
{
  static const int value = a * b;
};

template <int a, int b>
struct calculate_next<a, b, true>
{
  static const int value = 0; // any value will do here, calculation will short-circuit anyway
};

所以，那应该是它。我们需要一个额外的助手

template <int x, int N>
struct has_integral_root
{
  static const int root = static_root<x, N>::value;
  static const bool value = (static_pow<root, N>::value == x);
};

现在我们可以按如下方式实现ratio_pow：

template <typename, typename> struct ratio_pow;

template <int N1, int D1, int N2, int D2>
struct ratio_pow<std::ratio<N1, D1>, std::ratio<N2, D2>>
{
  // ensure that all roots are integral
  static_assert(has_integral_root<std::ratio<N1, D1>::num, std::ratio<N2, D2>::den>::value, "numerator has no integral root");
  static_assert(has_integral_root<std::ratio<N1, D1>::den, std::ratio<N2, D2>::den>::value, "denominator has no integral root");
  // calculate the "D2"-th root of (N1 / D1)
  static const int num1 = static_root<std::ratio<N1, D1>::num, std::ratio<N2, D2>::den>::value;
  static const int den1 = static_root<std::ratio<N1, D1>::den, std::ratio<N2, D2>::den>::value;
  // exchange num1 and den1 if the exponent is negative and set the exp to the absolute value of the exponent
  static const bool positive_exponent = std::ratio<N2, D2>::num >= 0;
  static const int num2 = positive_exponent ? num1 : den1;
  static const int den2 = positive_exponent ? den1 : num1;
  static const int exp = positive_exponent ? std::ratio<N2, D2>::num : - std::ratio<N2, D2>::num;
  //! calculate (num2 / den2) ^ "N2"
  typedef std::ratio<static_pow<num2, exp>::value, static_pow<den2, exp>::value> type;
};

所以，我希望至少有基本的想法。

Answer 2

是的，这是可能的。

设定R1 = P1 / Q1，R2 = P2 / Q2，R1 ^ R2 = R3 = P3 / Q3。进一步假设P和Q是共素数。

R1^R2 = R1^(P2/Q2) = R3
R1 ^ P2 = R3 ^ Q2.

R1^P2已知并且具有素数的唯一因子2^a * 3^b * 5^c * ...请注意a, b, c可以是负数，因为R1是P1/Q1。现在第一个问题是a,b,c是否都是已知因子Q2的倍数。如果没有，那么你就直接失败了。如果是，则为R3 = 2^(a/Q2) * 3^(b/Q2) * 5^(c/Q2) ...。

所有分区都是精确的或结果不存在，因此我们可以在模板中使用纯整数数学。在模板中对一个数字进行保理是相当简单的（x%y==0）的部分特化。

示例：2 ^（1/2）= R3 - > a = 1，b = 0，c = 0，...和a%2 != 0 - ＆gt;不可能。（1/9）^（1/2） - ＆gt; a = 0，b = -2，b％2 = 0，可能，结果= 3 ^（ - 2/2）。

std ::比率在编译时的std :: ratio的功率？

2 个答案: