Question

我在c ++中进行定点实现，我正在尝试定义“not-a-number”并支持函数bool isnan（...），如果数字不是-a，则返回true，否则返回false。 / p>

有人可以给我一些关于如何定义“非数字”的想法，并在我的定点数学实现中实现一个函数bool isnan（...）。

我已经阅读了关于C ++ Nan的内容，但我无法获得任何关于如何手动定义和创建函数nan（）以在定点实现中使用它的源或参考。

有人可以告诉我如何继续或提供一些参考资料吗？

谢谢

更新固定点标题

#ifndef __fixed_point_header_h__
#define __fixed_point_header_h__
#include <boost/operators.hpp>
#include <boost/assert.hpp>
#endif
namespace fp {
    template<typename FP, unsigned char I, unsigned char F>
    class fixed_point: boost::ordered_field_operators<fp::fixed_point<FP, I, F>  >
    { 
    //compute the power of 2 at compile time by template recursion
    template<int P,typename T = void> 
    struct power2
    {
        static const long long value = 2 * power2<P-1,T>::value;
    };

    template <typename P>
    struct power2<0, P>
    {
        static const long long value = 1;
    };
    fixed_point(FP value,bool): fixed_(value){ } // initializer list
    public:
    typedef FP base_type; ///  fixed point base type of this fixed_point class.
    static const unsigned char integer_bit_count = I; ///  integer part bit count.
    static const unsigned char fractional_bit_count = F; /// fractional part bit count.
    fixed_point(){ } /// Default constructor.

    //Integer to Fixed point
    template<typename T> fixed_point(T value) : fixed_((FP)value << F)
   {
    BOOST_CONCEPT_ASSERT((boost::Integer<T>)); 
    }
    //floating point to fixed point
    fixed_point(float value) :fixed_((FP)(value * power2<F>::value)){ }
    fixed_point(double value) : fixed_((FP)(value * power2<F>::value))  { }
    fixed_point(long double value) : fixed_((FP)(value * power2<F>::value)) { }
    /// Copy constructor,explicit definition
    fixed_point(fixed_point<FP, I, F> const& rhs): fixed_(rhs.fixed_)
    { }

    // copy-and-swap idiom.

    fp::fixed_point<FP, I, F> & operator =(fp::fixed_point<FP, I, F> const& rhs)
    {
    fp::fixed_point<FP, I, F> temp(rhs); // First, make a copy of the right-hand side
    swap(temp); //swapping the copied(old) data the new data.
    return *this;  //return by reference
    }
    /// Exchanges the elements of two fixed_point objects.
    void swap(fp::fixed_point<FP, I, F> & rhs)
    {
        std::swap(fixed_, rhs.fixed_);
    }
    bool operator <(
        /// Right hand side.
        fp::fixed_point<FP, I, F> const& rhs) const
    {
        return fixed_ < rhs.fixed_;  //return by value
    }

    bool operator ==(
        /// Right hand side.
        fp::fixed_point<FP, I, F> const& rhs) const
    {
        return fixed_ == rhs.fixed_; //return by value
    }
    // Addition.
    fp::fixed_point<FP, I, F> & operator +=(fp::fixed_point<FP, I, F> const& summation)
    {
        fixed_ += summation.fixed_;
        return *this; //! /return A reference to this object.
    }
    /// Subtraction.
    fp::fixed_point<FP, I, F> & operator -=(fp::fixed_point<FP, I, F> const& subtraction)
    {
        fixed_ -= subtraction.fixed_;
        return *this;  // return A reference to this object.
    }
    // Multiplication.
    fp::fixed_point<FP, I, F> & operator *=(fp::fixed_point<FP, I, F> const& factor)
    {
    fixed_ = ( fixed_ * (factor.fixed_ >> F) ) +
        ( ( fixed_ * (factor.fixed_ & (power2<F>::value-1) ) ) >> F );
        return *this;   //return A reference to this object.
    }
    /// Division.
    fp::fixed_point<FP, I, F> & operator /=(fp::fixed_point<FP, I, F> const& divisor)
    {
     fp::fixed_point<FP, I, F> fp_z=1;
     fp_z.fixed_ = ( (fp_z.fixed_) << (F-2) ) / ( divisor.fixed_ >> (2) );
    *this *= fp_z;
     return *this;   //return A reference to this object
    }
private:
    /// The value in fixed point format.
    FP fixed_;
 };

} // namespace fmpl

#endif

#endif // __fixed_point_header__

Answer 1

通常，固定点数学用于没有FPU的嵌入式硬件。大多数情况下，这种硬件也缺乏程序或数据空间或/和处理能力。

您确定需要NAN，INF或以下版本的通用支持吗？可能只是在可以产生theese值的操作上作为单独的Flags显式实现它就足够了。

你使用定点运算，你必须知道你的数据，以避免多重或分裂的溢出或下溢。因此，您的算法必须以避免特殊条件的方式编写。

除此之外，使用double：一旦你的算法中有一个特殊的值，它们会像病毒一样传播，结果很无用。

作为结论：在我的意见中明确地在你的定点类中实现它是一个很大的处理能力浪费，因为你必须为每个fixpoint操作添加条件。条件对DSP或μC的深CPU流水线有害。

Answer 2

你能举个例子说明你的定点是什么意思吗？它是作为一个类实现的吗？它是固定的字节数，还是支持8,16,32,64位数？你如何表现负面价值？

根据这些因素，您可以采用一些不同的方式实现。 IEEE浮点数用它逃脱的方式是因为数字以特殊格式编码，允许根据位模式设置标志。在可能无法实现的定点实现中。但如果它是一个类，你可以为类定义算术运算符，然后将结果数设置为nan。

<强>更新

看看代码，你似乎只是将信息填入价值中。所以最好的方法可能是在类中有一个isnan标志，并从适当的数学运算中设置它，然后在执行操作之前检查它，以便isnan传播。

Answer 3

基本上，您必须留出一些值或一组值来表示NaN。在对象的每个操作中（例如，添加），您必须测试输入值是否为NaN并相应地做出响应。

此外，您必须确保没有正常操作无意中产生NaN结果。因此，您必须处理溢出等，以确保如果计算结果是NaN的位模式，则会产生无穷大和/或异常指示和/或所需的任何结果。

基本上就是这样;没有魔力。

通常，您不希望将单个位用作标志，因为这会浪费许多可用于表示值的位组合。 IEEE 754保留指数字段的一个值（全1）以指示无穷大（如果有效数字字段全为零）或NaN（否则）。这样，只有一小部分比特组合用于NaN。（对于32位，2个³²可能的位组合中有2个²⁴ -2 NaNs，因此少于.4％的潜在值消耗在NaN上。）

c ++函数bool isnan（...）的定点实现

3 个答案: