Question

我正在C开发一个特殊用途数学功能图书馆。我需要为图书馆提供处理单一视距和双重视距的能力。这里的重要一点是,“单一”功能应当使用奥文特内部的“单一”算术(“双重”功能)。

举例来说,请见LAPACK(Fortran),其中提供了每项职能的两个版本(SINGLE和DOUBLE)。 C 数学图书馆(Example,expf和exp)。

为了澄清,我要支持类似以下(持续)例子:

float MyFloatFunc(float x) {
    return expf(-2.0f * x)*logf(2.75f*x);
}

double MyDoubleFunc(double x) {
    return exp(-2.0 * x)*log(2.75*x);
}

我对以下做法进行了思考:

利用宏观方法确定功能名称。这仍然需要两个单独的源代码基:

#ifdef USE_FLOAT
#define MYFUNC MyFloatFunc
#else
#define MYFUNC MyDoubleFunc
#endif

利用宏观处理浮动点类型。这使我能够分享两个不同版本的编码基础:
```
#ifdef USE_FLOAT
#define NUMBER float
#else
#define NUMBER double
#endif
```
仅仅开发两个单独的图书馆,并设法挽救头痛。

是否有任何人提出建议或补充建议?

Answer 1

对于多功能的近似、干涉和其他固有的近似的数学功能,你不能在双重计算和单一精度执行之间分享代码,而不必在单一精度版本中浪费时间,或比重复计算时更具有相关性。

然而,如果你走到单一编码基线的路,那么以下工作就是为了履行固定和标准图书馆职能:

#ifdef USE_FLOAT
#define C(x) x##f
#else
#define C(x) x
#endif

... C(2.0) ... C(sin) ...

Answer 2

(Partially inspired by Pascal Cuoq s answer) If you want one library with float and double versions of everything, you could use recursive #includes in combination with macros. It doesn t result in the clearest of code, but it does let you use the same code for both versions, and the obfuscation is thin enough it s probably manageable:

<>strong>mylib.h:

#ifndef MYLIB_H_GUARD
  #ifdef MYLIB_H_PASS2
    #define MYLIB_H_GUARD 1
    #undef C
    #undef FLT
    #define C(X) X
    #define FLT double
  #else
    /* any #include s needed in the header go here */

    #undef C
    #undef FLT
    #define C(X) X##f
    #define FLT float
  #endif

  /* All the dual-version stuff goes here */
  FLT C(MyFunc)(FLT x);

  #ifndef MYLIB_H_PASS2
    /* prepare 2nd pass (for  double  version) */
    #define MYLIB_H_PASS2 1
    #include "mylib.h"
  #endif
#endif /* guard */

<>strong>mylib.c:

#ifdef MYLIB_C_PASS2
  #undef C
  #undef FLT
  #define C(X) X
  #define FLT double
#else
  #include "mylib.h"
  /* other #include s */

  #undef C
  #undef FLT
  #define C(X) X##f
  #define FLT float
#endif

/* All the dual-version stuff goes here */
FLT C(MyFunc)(FLT x)
{
  return C(exp)(C(-2.0) * x) * C(log)(C(2.75) * x);
}

#ifndef MYLIB_C_PASS2
  /* prepare 2nd pass (for  double  version) */
  #define MYLIB_C_PASS2 1
  #include "mylib.c"
#endif

每一文档#include在使用第二份通行证的不同宏观定义时,又一次生成两种使用宏观代码。

Some people may object to this approach, though.

Answer 3

你们要面对的主要问题是:

Is it easier to maintain two separate unobfuscated source trees, or one obfuscated one?

如果你有拟议的共同编码,你必须谨慎地起草该守则,不要书写任何未加更正的固定或非常规功能电话(或职能机构)。

If you have separate source code trees, the code will be simpler to maintain in that each tree will look like normal (non-obfuscated) C code, but if there is a bug in YourFunctionA in the float version, will you always remember to make the matching change in the double version.

我认为,这取决于职能的复杂性和波动性。我怀疑,一旦写成并第一次 de倒,很少需要回头来。这实际上意味着你使用的机制确实很重要——两者都是可行的。如果职能机构有些不稳定,或职能清单不稳定,则单一编码基数总体可能比较容易。如果一切都非常稳定,两个单独的法典基础的清晰度可能更可取。但它非常主观。

我也许会拿到一个单一的代码基数和墙对墙的宏观。但我并不认为这是最好的,而另一种方式也有好处。

Answer 4

The <tgmath.h> header, standardized in C 1999, provides type-generic calls to the routines in <math.h> and <complex.h>. After you include <tgmath.h>;, the source text sin(x) will call sinl if x is long double, sin if x is double, and sinf if x is float.

您仍需要确定您的常数,以便您酌情使用<代码>3.1<>/code>或3.1f。根据你们的需要和你看来更多的美学,这方面有多种合成技术。对于在<代码>float精确度上准确代表的固定装置,你只能使用浮动表格。例如,y = .5f * x将自动转换.5f至double<>code>。但sin(.5f)将产生sinf(.5f),其准确性低于sin(.5)。


您也许能够将有条件化降低到一个单一的明确定义:
#if defined USE_FLOAT
    typedef float Float;
#else
    typedef double Float;
#endif

这样,你就可以以这样的方式使用不变:
const Float pi = 3.14159265358979323846233;
Float y = sin(pi*x);
Float z = (Float) 2.71828182844 * x;

这可能并不完全令人满意,因为很少出现将数字转换为<条码>、杜布莱,然后改为<条码>float<>/代码>,其准确性低于直接转换为<条码>float的数值。 因此,如果有必要,可在<条码>C( 数>>>上对数字作必要的补充。

友情链接