4

我目前正在通过模板元编程实现编译时 3d 栅格。

在实现了代数基础（2d/3d/4d 向量、3x3/4x4 矩阵算术、用于剔除目的的 aabb2d/3d 等）之后，我注意到整数算术对于向量转换来说不够好。于是我开始写定点实现：

该库有一个基本标头，其中声明了代数类型将实现的通用元函数（提供统一接口）。这是定点实现使用的一组定义：

template<typename T>
struct zero; //Gets the zero value of a type of data. For example, zero<std::integral_constant<int>> returns std::integral_constant<int,0>

template<typename T>
struct one;

/* Algebraic operations: */

template<typename LHS , typename RHS>
struct add;

template<typename LHS , typename RHS>
struct sub;

template<typename LHS , typename RHS>
struct mul;

我决定使用基于十进制的定点而不是基于二进制的定点，因为它允许我轻松编写十进制数接口（decimal别名在下面提供）。这是幂元函数和十进制数字移位的实现：

template<int base , int exponent>
struct positive_pow : public std::integral_constant<long long int , base * positive_pow<base,exponent-1>::value> {};

template<int base>
struct positive_pow<base,0> : public std::integral_constant<long long int,1> {};

template<int number , int shift>
struct decimal_leftshift : public std::integral_constant<long long int,number * positive_pow<10, shift>::value> {};

template<int number , int shift>
struct decimal_rightshift : public std::integral_constant<long long int,number / positive_pow<10, shift>::value> {};

template<bool CONDITION , int NUMBER , int SHIFT>
struct decimal_shift_chooser
{
    using shifter = decimal_leftshift<NUMBER,SHIFT>;
};

template<int NUMBER , int SHIFT>
struct decimal_shift_chooser<false,NUMBER,SHIFT>
{
    using shifter = decimal_rightshift<NUMBER,-SHIFT>;
};

//This metafunction shifts to one direction or other depending on the sign of the shift count passed:
template<int number , int shift>
struct decimal_shift
{
    using shifter = typename decimal_shift_chooser<( shift >= 0 ) , number , shift>::shifter;
    static const long long int value = shifter::value;
};

这里是定点类型的实现。内部实现使用 along long来存储数字。所以我有 64 位，即大约19 位十进制数字：

using fpbits = long long int;
using fdcount = unsigned int; //Fractional decimal digits count (Precision)

const fdcount DEFAULT_FRACTIONAL_PRECISION = 8; 

template<fpbits BITS , fdcount PRECISION = DEFAULT_FRACTIONAL_PRECISION>
struct fixed_point
{
    operator float()
    {
        return (float)BITS * std::pow(10.0f,-(float)PRECISION);
    };
};

//An alias to define decimal numbers with default precision:
template<int mantissa , int exponent = 0> // MANTISSA x 10^EXPONENT
using decimal = fixed_point<decimal_shift<mantissa , DEFAULT_FRACTIONAL_PRECISION + exponent>::value>; 

/* Previously defined common metafunctions implementation */

template<fpbits BITS , fdcount PRECISION>
struct zero<fixed_point<BITS,PRECISION>> : public fixed_point<0,PRECISION> {};

template<fpbits BITS , fdcount PRECISION>
struct one<fixed_point<BITS,PRECISION>> : public fixed_point<decimal_leftshift<1,PRECISION>::value,PRECISION> {};


template<fpbits BITS1 , fdbits BITS2 , fbcount PRECISION>
struct add<fixed_point<BITS1,PRECISION> , fixed_point<BITS2,PRECISION>> : public fixed_point<BITS1+BITS2 , PRECISION> {};

template<fpbits BITS1 , fdbits BITS2 , fbcount PRECISION>
struct sub<fixed_point<BITS1,PRECISION> , fixed_point<BITS2,PRECISION>> : public fixed_point<BITS1-BITS2 , PRECISION> {};

template<fpbits BITS1 , fdbits BITS2 , fbcount PRECISION>
struct mul<fixed_point<BITS1,PRECISION> , fixed_point<BITS2,PRECISION>> : public fixed_point<decimal_rightshift<BITS1*BITS2,PRECISION>::value , PRECISION> {};

正如我所指出的，该实现有 19 个十进制数字。因此，如果我们使用8 位小数精度并将 pi 乘以 2，则可以表示结果，对吗？就像在这个例子中一样：

using pi = decimal<3141592 , -6>; //3141592 x 10^-6 (3,141592) This fits in our 8 precision implementation.
using pi_2 = mul<pi,decimal<2>>; //pi*2 is 314159200 * 200000000 = 62831840000000000 >> 8. 
                                 //The inmediate result of the product fits in a 
                                 //long long (Has 17 decimal digits), so no problem?

int main()
{
    std::cout << "pi: " << pi() << std::endl;
    std::cout << "2*pi: " << pi_2() << std::endl;
}

但这打印：

pi: 3,14159
pi*2: -1e-07

如您所见，结果是一个很小的负数，所以我认为计算中的任何地方都存在有符号整数溢出。

哪里有问题？这是一个整数溢出，如果它是真的，我可以在哪里以及如何修复它？

这是一个完整的运行示例。

4

2 回答 2

4

你decimal_rightshift有一个int参数，你传递BITS1*BIST2给它。int用你的元程序中的每个替换long long int，一切都应该工作。

于 2013-08-03T14:32:07.120 回答
1

顺便说一句，你one是不正确的。正确的实现是：

template<fpbits BITS , fbcount PRECISION>
struct one<fixed_point<BITS,PRECISION>> : public fixed_point<decimal_leftshift<1, PRECISION>::value, PRECISION> {};

也就是说，假设one实际上应该是值一。

于 2013-08-03T14:57:17.707 回答