blob: 9bbb0dbc369b39494e6d23ccf4d71f52012746ec (
plain)
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
127
128
129
130
131
132
133
134
135
136
137
138
|
// -*- C++ -*-
//=============================================================================
/**
* @file OS_NS_math.h
*
* @author Douglas C. Schmidt <d.schmidt@vanderbilt.edu>
* @author Jesper S. M|ller<stophph@diku.dk>
* @author and a cast of thousands...
*/
//=============================================================================
#ifndef ACE_OS_NS_MATH_H
# define ACE_OS_NS_MATH_H
# include /**/ "ace/pre.h"
# include "ace/config-all.h"
# if !defined (ACE_LACKS_PRAGMA_ONCE)
# pragma once
# endif /* ACE_LACKS_PRAGMA_ONCE */
#include "ace/os_include/os_math.h"
#include /**/ "ace/ACE_export.h"
#if defined (ACE_EXPORT_MACRO)
# undef ACE_EXPORT_MACRO
#endif
#define ACE_EXPORT_MACRO ACE_Export
/*
* We inline and undef some functions that may be implemented
* as macros on some platforms. This way macro definitions will
* be usable later as there is no way to save the macro definition
* using the pre-processor.
*/
inline double ace_log2_helper (double x)
{
#if defined (log2)
return log2 (x);
#undef log2
#else
# if !defined (ACE_LACKS_LOG2)
return ACE_STD_NAMESPACE::log2 (x);
# else
/*
==================================================================
log (x)
k
log (x) = -------
b log (b)
k
meaning the binary logarithm of x using the natural logarithm, for
example, is:
log (x)
e
log (x) = -------
2 log (2)
e
==================================================================
*/
// Precomputed value of 1/log(2.0). Saves an expensive division and
// computing log(2.0) in each call.
double const _1_ln2 = 1.442695040888963407359924681002;
return log (x) * _1_ln2;
# endif /* !ACE_LACKS_LOG2 */
#endif /* defined (log2) */
}
ACE_BEGIN_VERSIONED_NAMESPACE_DECL
namespace ACE_OS
{
/// This method computes the largest integral value not greater than x.
template <typename T>
inline
T floor (T x)
{
return ACE_STD_NAMESPACE::floor (x);
}
#if defined (ACE_HAS_WINCE)
/// Windows CE has an intrinsic floor for float
template <>
inline
float floor (float x)
{
return ACE_STD_NAMESPACE::floorf (x);
}
#endif
/// This method computes the smallest integral value not less than x.
template <typename T>
inline
T ceil (T x)
{
return ACE_STD_NAMESPACE::ceil (x);
}
#if defined (ACE_HAS_WINCE)
/// Windows CE has an intrinsic ceil for float
template <>
inline
float ceil (float x)
{
return ACE_STD_NAMESPACE::ceilf (x);
}
#endif
/// This method computes the base-2 logarithm of x.
ACE_NAMESPACE_INLINE_FUNCTION
double log2 (double x);
} /* namespace ACE_OS */
ACE_END_VERSIONED_NAMESPACE_DECL
# if defined (ACE_HAS_INLINED_OSCALLS)
# if defined (ACE_INLINE)
# undef ACE_INLINE
# endif /* ACE_INLINE */
# define ACE_INLINE inline
# include "ace/OS_NS_math.inl"
# endif /* ACE_HAS_INLINED_OSCALLS */
# include /**/ "ace/post.h"
#endif /* ACE_OS_NS_MATH_H */
|
