1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
|
#include <cstdio>
template<typename T> struct SincosReference
{
const T x, s, c;
};
template<typename T> struct Reference
{
const T x, ref;
};
template<typename T> struct Data
{
static const SincosReference<T> sincosReference[];
static const Reference<T> asinReference[];
static const Reference<T> acosReference[];
static const Reference<T> atanReference[];
static const Reference<T> lnReference[];
static const Reference<T> log2Reference[];
static const Reference<T> log10Reference[];
};
namespace Function {
enum Function {
sincos, atan, asin, acos, ln, log2, log10
};
}
template<typename T, Function::Function F> static inline const char *filenameOut();
template<> inline const char *filenameOut<float , Function::sincos>() { return "sincos-reference-single.dat"; }
template<> inline const char *filenameOut<double, Function::sincos>() { return "sincos-reference-double.dat"; }
template<> inline const char *filenameOut<float , Function::atan >() { return "atan-reference-single.dat"; }
template<> inline const char *filenameOut<double, Function::atan >() { return "atan-reference-double.dat"; }
template<> inline const char *filenameOut<float , Function::asin >() { return "asin-reference-single.dat"; }
template<> inline const char *filenameOut<double, Function::asin >() { return "asin-reference-double.dat"; }
template<> inline const char *filenameOut<float , Function::acos >() { return "acos-reference-single.dat"; }
template<> inline const char *filenameOut<double, Function::acos >() { return "acos-reference-double.dat"; }
template<> inline const char *filenameOut<float , Function::ln >() { return "reference-ln-sp.dat"; }
template<> inline const char *filenameOut<double, Function::ln >() { return "reference-ln-dp.dat"; }
template<> inline const char *filenameOut<float , Function::log2 >() { return "reference-log2-sp.dat"; }
template<> inline const char *filenameOut<double, Function::log2 >() { return "reference-log2-dp.dat"; }
template<> inline const char *filenameOut<float , Function::log10 >() { return "reference-log10-sp.dat"; }
template<> inline const char *filenameOut<double, Function::log10 >() { return "reference-log10-dp.dat"; }
template<> const SincosReference<float> Data<float>::sincosReference[] = {
#include "sincos-reference-single.h"
};
template<> const SincosReference<double> Data<double>::sincosReference[] = {
#include "sincos-reference-double.h"
};
template<> const Reference<float> Data<float>::asinReference[] = {
#include "asin-reference-single.h"
};
template<> const Reference<double> Data<double>::asinReference[] = {
#include "asin-reference-double.h"
};
template<> const Reference<float> Data<float>::acosReference[] = {
#include "acos-reference-single.h"
};
template<> const Reference<double> Data<double>::acosReference[] = {
#include "acos-reference-double.h"
};
template<> const Reference<float> Data<float>::atanReference[] = {
#include "atan-reference-single.h"
};
template<> const Reference<double> Data<double>::atanReference[] = {
#include "atan-reference-double.h"
};
template<> const Reference<float> Data<float>::lnReference[] = {
#include "reference-ln-sp.h"
};
template<> const Reference<double> Data<double>::lnReference[] = {
#include "reference-ln-dp.h"
};
template<> const Reference<float> Data<float>::log2Reference[] = {
#include "reference-log2-sp.h"
};
template<> const Reference<double> Data<double>::log2Reference[] = {
#include "reference-log2-dp.h"
};
template<> const Reference<float> Data<float>::log10Reference[] = {
#include "reference-log10-sp.h"
};
template<> const Reference<double> Data<double>::log10Reference[] = {
#include "reference-log10-dp.h"
};
template<typename T>
static void convert()
{
FILE *file;
file = fopen(filenameOut<T, Function::sincos>(), "wb");
fwrite(&Data<T>::sincosReference[0], sizeof(SincosReference<T>), sizeof(Data<T>::sincosReference) / sizeof(SincosReference<T>), file);
fclose(file);
file = fopen(filenameOut<T, Function::atan>(), "wb");
fwrite(&Data<T>::atanReference[0], sizeof(Reference<T>), sizeof(Data<T>::atanReference) / sizeof(Reference<T>), file);
fclose(file);
file = fopen(filenameOut<T, Function::asin>(), "wb");
fwrite(&Data<T>::asinReference[0], sizeof(Reference<T>), sizeof(Data<T>::asinReference) / sizeof(Reference<T>), file);
fclose(file);
file = fopen(filenameOut<T, Function::acos>(), "wb");
fwrite(&Data<T>::acosReference[0], sizeof(Reference<T>), sizeof(Data<T>::acosReference) / sizeof(Reference<T>), file);
fclose(file);
file = fopen(filenameOut<T, Function::ln>(), "wb");
fwrite(&Data<T>::lnReference[0], sizeof(Reference<T>), sizeof(Data<T>::lnReference) / sizeof(Reference<T>), file);
fclose(file);
file = fopen(filenameOut<T, Function::log2>(), "wb");
fwrite(&Data<T>::log2Reference[0], sizeof(Reference<T>), sizeof(Data<T>::log2Reference) / sizeof(Reference<T>), file);
fclose(file);
file = fopen(filenameOut<T, Function::log10>(), "wb");
fwrite(&Data<T>::log10Reference[0], sizeof(Reference<T>), sizeof(Data<T>::log10Reference) / sizeof(Reference<T>), file);
fclose(file);
}
int main()
{
convert<float>();
convert<double>();
return 0;
}
|
