A Discrete-Event Network Simulator
Home
Tutorials ▼
English
Documentation ▼
Installation
Manual
Models
Contributing
Wiki
Development ▼
API Docs
Issue Tracker
Merge Requests
API
Loading...
Searching...
No Matches
int64x64.h
Go to the documentation of this file.
1
/*
2
* Copyright (c) 2010 INRIA
3
*
4
* SPDX-License-Identifier: GPL-2.0-only
5
*/
6
7
#ifndef INT64X64_H
8
#define INT64X64_H
9
10
#include "ns3/core-config.h"
11
12
// Order is important here, as it determines which implementation
13
// will generate doxygen API docs. This order mimics the
14
// selection logic in CMakeLists.txt, so we generate docs from the
15
// implementation actually chosen by the configuration.
16
#if defined(INT64X64_USE_128) && !defined(PYTHON_SCAN)
17
#include "
int64x64-128.h
"
18
#elif defined(INT64X64_USE_CAIRO) && !defined(PYTHON_SCAN)
19
#include "
int64x64-cairo.h
"
20
#elif defined(INT64X64_USE_DOUBLE) || defined(PYTHON_SCAN)
21
#include "
int64x64-double.h
"
22
#endif
23
24
#include <iostream>
25
26
/**
27
* \file
28
* \ingroup highprec
29
* Declaration of the ns3::int64x64_t type and associated operators.
30
*/
31
32
namespace
ns3
33
{
34
35
/**
36
* \ingroup core
37
* \defgroup highprec High Precision Q64.64
38
*
39
* Functions and class for high precision Q64.64 fixed point arithmetic.
40
*
41
* A Q64.64 fixed precision number consists of:
42
*
43
* Bits | Function
44
* ---- | --------
45
* 1 | Sign bit
46
* 63 | Integer portion
47
* 64 | Fractional portion
48
*
49
* The `high` word consists of the sign bit and integer value;
50
* the `low` word is the fractional part, unscaled.
51
*
52
* All standard arithmetic operations are supported:
53
*
54
* Category | Operators
55
* ----------- | ---------
56
* Computation | `+`, `+=`, `-`, `-=`, `*`, `*=`, `/`, `/=`
57
* Comparison | `==`, `!=`, `<`, `<=`, `>`, `>=`
58
* Unary | `+`, `-`, `!`
59
*/
60
61
/**
62
* \ingroup highprec
63
* \class int64x64_t
64
*
65
* High precision numerical type, implementing Q64.64 fixed precision.
66
*/
67
68
/**
69
* \ingroup highprec
70
* Addition operator.
71
* \param [in] lhs Left hand argument
72
* \param [in] rhs Right hand argument
73
* \return The result of the operator.
74
*/
75
inline
int64x64_t
76
operator+
(
const
int64x64_t
& lhs,
const
int64x64_t
& rhs)
77
{
78
int64x64_t
tmp = lhs;
79
tmp += rhs;
80
return
tmp;
81
}
82
83
/**
84
* \ingroup highprec
85
* Subtraction operator.
86
* \param [in] lhs Left hand argument
87
* \param [in] rhs Right hand argument
88
* \return The result of the operator.
89
*/
90
inline
int64x64_t
91
operator-
(
const
int64x64_t
& lhs,
const
int64x64_t
& rhs)
92
{
93
int64x64_t
tmp = lhs;
94
tmp -= rhs;
95
return
tmp;
96
}
97
98
/**
99
* \ingroup highprec
100
* Multiplication operator.
101
* \param [in] lhs Left hand argument
102
* \param [in] rhs Right hand argument
103
* \return The result of the operator.
104
*/
105
inline
int64x64_t
106
operator*
(
const
int64x64_t
& lhs,
const
int64x64_t
& rhs)
107
{
108
int64x64_t
tmp = lhs;
109
tmp *= rhs;
110
return
tmp;
111
}
112
113
/**
114
* \ingroup highprec
115
* Division operator.
116
* \param [in] lhs Left hand argument
117
* \param [in] rhs Right hand argument
118
* \return The result of the operator.
119
*/
120
inline
int64x64_t
121
operator/
(
const
int64x64_t
& lhs,
const
int64x64_t
& rhs)
122
{
123
int64x64_t
tmp = lhs;
124
tmp /= rhs;
125
return
tmp;
126
}
127
128
/**
129
* \ingroup highprec
130
* Inequality operator
131
* \param [in] lhs Left hand argument
132
* \param [in] rhs Right hand argument
133
* \return The result of the operator.
134
*/
135
inline
bool
136
operator!=
(
const
int64x64_t
& lhs,
const
int64x64_t
& rhs)
137
{
138
return
!(lhs == rhs);
139
}
140
141
/**
142
* \ingroup highprec
143
* Less or equal operator.
144
* \param [in] lhs Left hand argument
145
* \param [in] rhs Right hand argument
146
* \return The result of the operator.
147
*/
148
inline
bool
149
operator<=
(
const
int64x64_t
& lhs,
const
int64x64_t
& rhs)
150
{
151
return
!(lhs > rhs);
152
}
153
154
/**
155
* \ingroup highprec
156
* Greater or equal operator.
157
* \param [in] lhs Left hand argument
158
* \param [in] rhs Right hand argument
159
* \return The result of the operator.
160
*/
161
inline
bool
162
operator>=
(
const
int64x64_t
& lhs,
const
int64x64_t
& rhs)
163
{
164
return
!(lhs < rhs);
165
}
166
167
/**
168
* \ingroup highprec
169
* Output streamer for int64x64_t.
170
*
171
* Values are printed with the following format flags
172
* (independent of the stream flags):
173
* - `showpos`
174
* - `left`
175
*
176
* The stream `width` is ignored. If `floatfield` is set,
177
* `precision` decimal places are printed. If `floatfield` is not set,
178
* all digits of the fractional part are printed, up to the
179
* representation limit of 20 digits; trailing zeros are omitted.
180
*
181
* \param [in,out] os The output stream.
182
* \param [in] value The numerical value to print.
183
* \returns The stream.
184
*/
185
std::ostream&
operator<<
(std::ostream& os,
const
int64x64_t& value);
186
/**
187
* \ingroup highprec
188
* Input streamer for int64x64_t.
189
*
190
* \param [in,out] is The input stream.
191
* \param [out] value The numerical value to set.
192
* \returns The stream.
193
*/
194
std::istream&
operator>>
(std::istream& is, int64x64_t& value);
195
196
/**
197
* \ingroup highprec
198
* Absolute value.
199
* \param [in] value The value to operate on.
200
* \return The absolute value of \pname{value}.
201
*/
202
inline
int64x64_t
203
Abs
(
const
int64x64_t
& value)
204
{
205
return
(value < 0) ? -value : value;
206
}
207
208
/**
209
* \ingroup highprec
210
* Minimum.
211
*
212
* \param [in] a The first value.
213
* \param [in] b The second value.
214
* \return The smaller of the arguments.
215
*/
216
inline
int64x64_t
217
Min
(
const
int64x64_t
& a,
const
int64x64_t
& b)
218
{
219
return
(a < b) ? a : b;
220
}
221
222
/**
223
* \ingroup highprec
224
* Maximum.
225
*
226
* \param [in] a The first value.
227
* \param [in] b The second value.
228
* \return The larger of the arguments.
229
*/
230
inline
int64x64_t
231
Max
(
const
int64x64_t
& a,
const
int64x64_t
& b)
232
{
233
return
(a > b) ? a : b;
234
}
235
236
}
// namespace ns3
237
238
#endif
/* INT64X64_H */
Max
#define Max(a, b)
Definition
aarf-wifi-manager.cc:15
Min
#define Min(a, b)
Definition
aarf-wifi-manager.cc:14
ns3::int64x64_t
High precision numerical type, implementing Q64.64 fixed precision.
Definition
int64x64-double.h:34
ns3::operator/
int64x64_t operator/(const int64x64_t &lhs, const int64x64_t &rhs)
Division operator.
Definition
int64x64.h:121
ns3::operator>=
bool operator>=(const int64x64_t &lhs, const int64x64_t &rhs)
Greater or equal operator.
Definition
int64x64.h:162
ns3::operator<=
bool operator<=(const int64x64_t &lhs, const int64x64_t &rhs)
Less or equal operator.
Definition
int64x64.h:149
ns3::operator-
int64x64_t operator-(const int64x64_t &lhs, const int64x64_t &rhs)
Subtraction operator.
Definition
int64x64.h:91
ns3::operator+
int64x64_t operator+(const int64x64_t &lhs, const int64x64_t &rhs)
Addition operator.
Definition
int64x64.h:76
ns3::Abs
int64x64_t Abs(const int64x64_t &value)
Absolute value.
Definition
int64x64.h:203
ns3::operator*
int64x64_t operator*(const int64x64_t &lhs, const int64x64_t &rhs)
Multiplication operator.
Definition
int64x64.h:106
int64x64-128.h
Declaration of the ns3::int64x64_t type using a native int128_t type.
int64x64-cairo.h
Using the ns3::int64x64_t based on Cairo 128-bit integers.
int64x64-double.h
Using the ns3::int64x64_t based on double values.
ns3
Every class exported by the ns3 library is enclosed in the ns3 namespace.
ns3::operator!=
bool operator!=(Callback< R, Args... > a, Callback< R, Args... > b)
Inequality test.
Definition
callback.h:658
ns3::operator<<
std::ostream & operator<<(std::ostream &os, const Angles &a)
Definition
angles.cc:148
ns3::operator>>
std::istream & operator>>(std::istream &is, Angles &a)
Definition
angles.cc:172
src
core
model
int64x64.h
Generated on Fri Nov 8 2024 13:58:59 for ns-3 by
1.11.0