CNL  2.0.2 (development)
Compositional Numeric Library
operators.h
1 
2 // Copyright John McFarlane 2018.
3 // Distributed under the Boost Software License, Version 1.0.
4 // (See accompanying file ../LICENSE_1_0.txt or copy at
5 // http://www.boost.org/LICENSE_1_0.txt)
6 
7 #if !defined(CNL_IMPL_DUPLEX_INTEGER_OPERATORS_H)
8 #define CNL_IMPL_DUPLEX_INTEGER_OPERATORS_H
9 
10 #include "../../integer.h"
11 #include "../../wide_integer.h"
12 #include "../charconv/to_chars.h"
13 #include "../config.h"
14 #include "../custom_operator/definition.h"
15 #include "../custom_operator/op.h"
16 #include "../likely.h"
17 #include "../num_traits/width.h"
18 #include "../type_traits/common_type.h"
19 #include "comparison.h"
20 #include "ctors.h"
21 #include "definition.h"
22 #include "digits.h"
23 #include "divide.h"
24 #include "modulo.h"
25 #include "multiply.h"
26 #include "numbers.h"
27 #include "numeric_limits.h"
28 #include "set_digits.h"
29 #include "shift.h"
30 
31 #include <limits>
32 #if defined(CNL_IOSTREAMS_ENABLED)
33 #include <ostream>
34 #endif
35 
37 namespace cnl {
38  namespace _impl {
39  // default binary arithmetic operator
40  template<binary_arithmetic_op Operator, typename Upper, typename Lower>
41  struct default_binary_arithmetic_operator {
42  private:
43  using operand = duplex_integer<Upper, Lower>;
44 
45  public:
46  [[nodiscard]] constexpr auto operator()(
47  operand const& lhs, operand const& rhs) const -> operand
48  {
49  return operand(
50  static_cast<Upper>(Operator{}(lhs.upper(), rhs.upper())),
51  static_cast<Lower>(Operator{}(lhs.lower(), rhs.lower())));
52  }
53  };
54 
55  // add_op and subtract_op
56  template<binary_arithmetic_op Operator, any_duplex_integer Lhs, any_duplex_integer Rhs>
57  struct first_degree_binary_arithmetic_operator {
58  };
59 
60  template<binary_arithmetic_op Operator, typename Upper, typename Lower>
61  struct first_degree_binary_arithmetic_operator<
62  Operator, duplex_integer<Upper, Lower>, duplex_integer<Upper, Lower>> {
63  private:
64  using operand = duplex_integer<Upper, Lower>;
65 
66  static constexpr auto lower_digits = digits_v<Lower>;
67  using wide_lower = set_digits_t<numbers::set_signedness_t<Lower, true>, lower_digits + 1>;
68 
69  public:
70  [[nodiscard]] constexpr auto operator()(
71  operand const& lhs, operand const& rhs) const -> operand
72  {
73  return from_sums(
74  static_cast<Upper>(Operator{}(lhs.upper(), rhs.upper())),
75  wide_lower(Operator{}(wide_lower{lhs.lower()}, wide_lower{rhs.lower()})));
76  }
77 
78  [[nodiscard]] static constexpr auto from_sums(
79  Upper const& upper_sum, wide_lower const& lower_sum) -> operand
80  {
81  return operand{
82  static_cast<Upper>(
83  upper_sum
84  + static_cast<Upper>(lower_sum >> constant<lower_digits>{})),
85  static_cast<Lower>(lower_sum)};
86  }
87  };
88 
89  template<
90  binary_arithmetic_op Operator,
91  integer LhsUpper, integer LhsLower,
92  integer RhsUpper, integer RhsLower>
93  struct first_degree_binary_arithmetic_operator<
94  Operator,
95  duplex_integer<LhsUpper, LhsLower>,
96  duplex_integer<RhsUpper, RhsLower>> {
97  using lhs_type = duplex_integer<LhsUpper, LhsLower>;
98  using rhs_type = duplex_integer<RhsUpper, RhsLower>;
99 
100  using lhs_upper_word = duplex_integer_upper_t<LhsUpper>;
101  using rhs_upper_word = duplex_integer_upper_t<RhsUpper>;
102  using common_word = decltype(std::declval<lhs_upper_word>() + std::declval<rhs_upper_word>());
103  static constexpr int max_digits = std::max(digits_v<lhs_type>, digits_v<rhs_type>);
104  using common_duplex_integer = narrowest_integer_t<max_digits, common_word>;
105 
106  [[nodiscard]] constexpr auto operator()(
107  lhs_type const& lhs, rhs_type const& rhs) const
108  -> common_duplex_integer
109  {
110  return first_degree_binary_arithmetic_operator<
111  Operator, common_duplex_integer, common_duplex_integer>{}(lhs, rhs);
112  }
113  };
114  }
115 
116  // unary
117  template<typename Upper, typename Lower>
118  struct custom_operator<
119  _impl::bitwise_not_op, op_value<_impl::duplex_integer<Upper, Lower>>> {
120  [[nodiscard]] constexpr auto operator()(_impl::duplex_integer<Upper, Lower> const& rhs)
121  const -> _impl::duplex_integer<Upper, Lower>
122  {
123  return _impl::duplex_integer<Upper, Lower>(~rhs.upper(), ~rhs.lower());
124  }
125  };
126 
127  // binary arithmetic
128  template<typename Upper, typename Lower>
129  struct custom_operator<_impl::minus_op, op_value<_impl::duplex_integer<Upper, Lower>>> {
130  [[nodiscard]] constexpr auto operator()(_impl::duplex_integer<Upper, Lower> const& rhs)
131  const -> _impl::duplex_integer<Upper, Lower>
132  {
133  return _impl::operate<_impl::bitwise_not_op>{}(
134  rhs - _impl::duplex_integer<Upper, Lower>{1});
135  }
136  };
137 
138  template<typename Upper, typename Lower>
139  struct custom_operator<_impl::plus_op, op_value<_impl::duplex_integer<Upper, Lower>>> {
140  [[nodiscard]] constexpr auto operator()(_impl::duplex_integer<Upper, Lower> const& rhs)
141  const -> _impl::duplex_integer<Upper, Lower>
142  {
143  return _impl::duplex_integer<Upper, Lower>(+rhs.upper(), +rhs.lower());
144  }
145  };
146 
147  template<_impl::binary_arithmetic_op Operator, _impl::any_duplex_integer Lhs, integer Rhs>
148  requires(!_impl::is_duplex_integer_v<Rhs>) struct custom_operator<Operator, op_value<Lhs>, op_value<Rhs>> {
149  [[nodiscard]] constexpr auto operator()(Lhs const& lhs, Rhs const& rhs) const
150  {
151  return _impl::operate<Operator>{}(lhs, Lhs{rhs});
152  }
153  };
154 
155  template<_impl::binary_arithmetic_op Operator, integer Lhs, _impl::any_duplex_integer Rhs>
156  requires(!_impl::is_duplex_integer_v<Lhs>) struct custom_operator<Operator, op_value<Lhs>, op_value<Rhs>> {
157  [[nodiscard]] constexpr auto operator()(Lhs const& lhs, Rhs const& rhs) const
158  {
159  return _impl::operate<Operator>{}(lhs, rhs);
160  }
161  };
162 
163  template<_impl::any_duplex_integer Lhs, _impl::any_duplex_integer Rhs>
164  struct custom_operator<_impl::add_op, op_value<Lhs>, op_value<Rhs>> {
165  [[nodiscard]] constexpr auto operator()(Lhs const& lhs, Rhs const& rhs) const
166  {
167  return _impl::first_degree_binary_arithmetic_operator<_impl::add_op, Lhs, Rhs>{}(lhs, rhs);
168  }
169  };
170 
171  template<_impl::any_duplex_integer Lhs, _impl::any_duplex_integer Rhs>
172  struct custom_operator<_impl::subtract_op, op_value<Lhs>, op_value<Rhs>> {
173  [[nodiscard]] constexpr auto operator()(Lhs const& lhs, Rhs const& rhs) const
174  {
175  return _impl::first_degree_binary_arithmetic_operator<_impl::subtract_op, Lhs, Rhs>{}(lhs, rhs);
176  }
177  };
178 
179  template<typename Upper, typename Lower>
180  struct custom_operator<
181  _impl::bitwise_or_op,
182  op_value<_impl::duplex_integer<Upper, Lower>>,
183  op_value<_impl::duplex_integer<Upper, Lower>>>
184  : _impl::default_binary_arithmetic_operator<_impl::bitwise_or_op, Upper, Lower> {
185  };
186 
187  template<typename Upper, typename Lower>
188  struct custom_operator<
189  _impl::bitwise_and_op,
190  op_value<_impl::duplex_integer<Upper, Lower>>,
191  op_value<_impl::duplex_integer<Upper, Lower>>>
192  : _impl::default_binary_arithmetic_operator<_impl::bitwise_and_op, Upper, Lower> {
193  };
194 
195  template<typename Upper, typename Lower>
196  struct custom_operator<
197  _impl::bitwise_xor_op,
198  op_value<_impl::duplex_integer<Upper, Lower>>,
199  op_value<_impl::duplex_integer<Upper, Lower>>>
200  : _impl::default_binary_arithmetic_operator<_impl::bitwise_xor_op, Upper, Lower> {
201  };
202 
203  template<
204  _impl::comparison_op Operator, typename LhsUpper, typename LhsLower, typename RhsUpper,
205  typename RhsLower>
206  struct custom_operator<
207  Operator,
208  op_value<_impl::duplex_integer<LhsUpper, LhsLower>>,
209  op_value<_impl::duplex_integer<RhsUpper, RhsLower>>> {
210  [[nodiscard]] constexpr auto operator()(
211  _impl::duplex_integer<LhsUpper, LhsLower> const& lhs,
212  _impl::duplex_integer<RhsUpper, RhsLower> const& rhs) const -> bool
213  {
214  using common_type = _impl::duplex_integer<
215  _impl::common_type_t<LhsUpper, RhsUpper>,
216  _impl::common_type_t<LhsLower, RhsLower>>;
217  return _impl::operate<Operator>{}(common_type{lhs}, common_type{rhs});
218  }
219  };
220 
221  // prefix operators
222  template<typename Upper, typename Lower>
223  struct custom_operator<
224  _impl::pre_increment_op, op_value<_impl::duplex_integer<Upper, Lower>>> {
225  [[nodiscard]] constexpr auto operator()(_impl::duplex_integer<Upper, Lower>& rhs) const
226  -> _impl::duplex_integer<Upper, Lower>
227  {
228  return CNL_UNLIKELY(rhs.lower() == std::numeric_limits<Lower>::max())
229  ? _impl::duplex_integer<
230  Upper, Lower>{++rhs.upper(), std::numeric_limits<Lower>::lowest()}
231  : _impl::duplex_integer<Upper, Lower>{rhs.upper(), ++rhs.lower()};
232  }
233  };
234 
235  template<typename Upper, typename Lower>
236  struct custom_operator<
237  _impl::pre_decrement_op, op_value<_impl::duplex_integer<Upper, Lower>>> {
238  [[nodiscard]] constexpr auto operator()(_impl::duplex_integer<Upper, Lower>& rhs) const
239  -> _impl::duplex_integer<Upper, Lower>
240  {
241  return CNL_UNLIKELY(rhs.lower() == std::numeric_limits<Lower>::lowest())
242  ? _impl::duplex_integer<
243  Upper,
244  Lower>{static_cast<Upper>(--rhs.upper()), std::numeric_limits<Lower>::max()}
245  : _impl::duplex_integer<Upper, Lower>{rhs.upper(), --rhs.lower()};
246  }
247  };
248 
249  namespace _impl {
251  // cnl::duplex_integer streaming
252 
253 #if defined(CNL_IOSTREAMS_ENABLED)
254  template<typename Upper, typename Lower>
255  auto& operator<<(std::ostream& out, duplex_integer<Upper, Lower> const& value)
256  {
257  return out << cnl::to_chars_static(value).chars.data();
258  }
259 #endif
260  }
261 }
262 
263 #endif // CNL_IMPL_DUPLEX_INTEGER_OPERATORS_H
numbers.h
std::numeric_limits::lowest
T lowest(T... args)
std::ostream
STL class.
cnl
compositional numeric library
Definition: abort.h:15
std::max
T max(T... args)
std::numeric_limits