16820722729

Committed 08 Aug 2025 02:52AM UTC coverage: 76.434% (-0.4%) from 76.797%

Build # 16820722729

Build Type

Pull #29

github

Committed by

web-flow

Commit Message

Merge e2ea9d579 into 4adca69e9

Pull Request Pull Request #29: Explicitly cast inside _mask

Run Details

3353 of 5056 branches covered (66.32%)

Branch coverage included in aggregate %.

188 of 196 new or added lines in 17 files covered. (95.92%)

11 existing lines in 2 files now uncovered.

2563 of 2684 relevant lines covered (95.49%)

29389233.51 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

49.09

/include/bitlib/bit-algorithms/transform_accumulate.hpp

// ================================= array_REF =================================== //
// Project:     The Experimental Bit Algorithms Library
// \file        accumulate.hpp
// Description: Implementation of accumulate
// Creator:     Vincent Reverdy
// Contributor: Peter McLean [2025]
// License:     BSD 3-Clause License
// ========================================================================== //

#ifndef _BIT_TRANSFORM_ACCUMULATE_HPP_INCLUDED
#define _BIT_TRANSFORM_ACCUMULATE_HPP_INCLUDED

#include "bitlib/bit-iterator/bit_iterator.hpp"
#include "bitlib/bit-iterator/bit_details.hpp"

namespace bit {

template <
    bool forward,
    bool initial_sub_word,
    typename RandomAccessItIn,
    typename RandomAccessItOut,
    typename T,
    typename BinaryOperation,
    typename BinaryOperationSubword>
  requires(
      (std::is_same_v<std::remove_cvref_t<std::iter_value_t<RandomAccessItIn>>,
                      std::remove_cvref_t<std::iter_value_t<RandomAccessItOut>>>))
constexpr auto transform_accumulate(
    bit_iterator<RandomAccessItIn> first,
    bit_iterator<RandomAccessItIn> last,
    bit_iterator<RandomAccessItOut> d_first,
    bit_iterator<RandomAccessItOut> d_last,
    T acc,
    BinaryOperation binary_op,
    BinaryOperationSubword binary_op_subword) {
  using word_type = typename bit_iterator<RandomAccessItOut>::word_type;
  using size_type = typename bit_iterator<RandomAccessItOut>::size_type;
  constexpr size_type digits = bitsof<word_type>();

  size_type total_bits_to_op = distance(first, last);

  RandomAccessItOut d_it;
  if constexpr (forward) {
    d_it = d_first.base();
  } else {
    d_it = d_last.base();
  }

  if constexpr (forward) {
    if (d_first.position() != 0) {
      size_type partial_bits_to_op = ::std::min(
          total_bits_to_op,
          digits - d_first.position());
      if (partial_bits_to_op != 0) {
        word_type word;
        std::tie(word, acc) = binary_op_subword(std::move(acc), get_masked_word<word_type>(first, partial_bits_to_op), partial_bits_to_op);
        *d_it = _bitblend(
            *d_it,
            word,
            d_first.position(),
            partial_bits_to_op);
        total_bits_to_op -= partial_bits_to_op;
        advance(first, partial_bits_to_op);
        advance(d_it, 1);
      }
    }
  } else {
    if (d_last.position() != 0) {
      size_type partial_bits_to_op = ::std::min(
          total_bits_to_op,
          d_last.position());
      if (partial_bits_to_op != 0) {
        advance(last, -partial_bits_to_op);
        word_type word;
        std::tie(word, acc) = binary_op_subword(std::move(acc), get_masked_word<word_type>(last, partial_bits_to_op), partial_bits_to_op);
        *d_it = _bitblend(
            *d_it,
            word,
            d_first.position(),
            partial_bits_to_op);
        total_bits_to_op -= partial_bits_to_op;
      }
    }
  }


  const size_type whole_words_to_op = total_bits_to_op / digits;
  const size_type remaining_bits_to_op = total_bits_to_op % digits;

  for (size_t i = 0; i < whole_words_to_op; i ++) {
    if constexpr (forward) {
      word_type word;
      std::tie(word, acc) = binary_op(std::move(acc), get_word<word_type>(first));
      *d_it = word;
      advance(first, digits);
      std::advance(d_it, 1);
    } else {
      advance(last, -digits);
      std::advance(d_it, -1);
      word_type word;
      std::tie(word, acc) = binary_op(std::move(acc), get_word<word_type>(last));
      *d_it = word;
    }
  }
  if (remaining_bits_to_op > 0) {
    if constexpr (forward) {
      word_type word;
      std::tie(word, acc) = binary_op_subword(std::move(acc), get_masked_word<word_type>(first, remaining_bits_to_op), remaining_bits_to_op);
      *d_it = _bitblend(
          *d_it,
          word,
          0,
          remaining_bits_to_op);

    } else {
      advance(last, -remaining_bits_to_op);
      std::advance(d_it, -1);
      word_type word;
      std::tie(word, acc) = binary_op_subword(std::move(acc), get_masked_word<word_type>(last, remaining_bits_to_op), remaining_bits_to_op);
      *d_it = _bitblend(
          *d_it,
          word,
          0,
          remaining_bits_to_op);
    }
  }

  return acc;
}

template <
    typename RandomAccessItIn,
    typename RandomAccessItOut,
    typename T,
    typename BinaryOperation,
    typename BinaryOperationSubword>
  requires(
      (std::is_same_v<std::remove_cvref_t<std::iter_value_t<RandomAccessItIn>>,
                      std::remove_cvref_t<std::iter_value_t<RandomAccessItOut>>>))
constexpr auto transform_accumulate_backward(
    const bit_iterator<RandomAccessItIn>& first,
    const bit_iterator<RandomAccessItIn>& last,
    const bit_iterator<RandomAccessItOut>& d_first,
    const bit_iterator<RandomAccessItOut>& d_last,
    const T& acc,
    BinaryOperation binary_op,
    BinaryOperationSubword binary_op_subword) {
  return transform_accumulate<false, true>(first, last, d_first, d_last, acc, binary_op, binary_op_subword);
}

} // namespace bit

#endif // _BIT_TRANSFORM_ACCUMULATE_HPP_INCLUDED

1	// ================================= array_REF =================================== //
2	// Project: The Experimental Bit Algorithms Library
3	// \file accumulate.hpp
4	// Description: Implementation of accumulate
5	// Creator: Vincent Reverdy
6	// Contributor: Peter McLean [2025]
7	// License: BSD 3-Clause License
8	// ========================================================================== //
9
10	#ifndef _BIT_TRANSFORM_ACCUMULATE_HPP_INCLUDED
11	#define _BIT_TRANSFORM_ACCUMULATE_HPP_INCLUDED
12
13	#include "bitlib/bit-iterator/bit_iterator.hpp"
14	#include "bitlib/bit-iterator/bit_details.hpp"
15
16	namespace bit {
17
18	template <
19	bool forward,
20	bool initial_sub_word,
21	typename RandomAccessItIn,
22	typename RandomAccessItOut,
23	typename T,
24	typename BinaryOperation,
25	typename BinaryOperationSubword>
26	requires(
27	(std::is_same_v<std::remove_cvref_t<std::iter_value_t<RandomAccessItIn>>,
28	std::remove_cvref_t<std::iter_value_t<RandomAccessItOut>>>))
29	constexpr auto transform_accumulate(	9✔
30	bit_iterator<RandomAccessItIn> first,
31	bit_iterator<RandomAccessItIn> last,
32	bit_iterator<RandomAccessItOut> d_first,
33	bit_iterator<RandomAccessItOut> d_last,
34	T acc,
35	BinaryOperation binary_op,
36	BinaryOperationSubword binary_op_subword) {	9✔
37	using word_type = typename bit_iterator<RandomAccessItOut>::word_type;	9✔
38	using size_type = typename bit_iterator<RandomAccessItOut>::size_type;	9✔
39	constexpr size_type digits = bitsof<word_type>();	18✔
40
41	size_type total_bits_to_op = distance(first, last);	18✔
42
43	RandomAccessItOut d_it;	18✔
44	if constexpr (forward) {
45	d_it = d_first.base();
46	} else {	9✔
47	d_it = d_last.base();	18✔
48	}	9✔
49
50	if constexpr (forward) {
51	if (d_first.position() != 0) {
52	size_type partial_bits_to_op = ::std::min(
53	total_bits_to_op,
54	digits - d_first.position());
55	if (partial_bits_to_op != 0) {
56	word_type word;
57	std::tie(word, acc) = binary_op_subword(std::move(acc), get_masked_word<word_type>(first, partial_bits_to_op), partial_bits_to_op);
58	*d_it = _bitblend(
59	*d_it,
60	word,
61	d_first.position(),
62	partial_bits_to_op);
63	total_bits_to_op -= partial_bits_to_op;
64	advance(first, partial_bits_to_op);
65	advance(d_it, 1);
66	}
67	}
68	} else {	9✔
69	if (d_last.position() != 0) {	18!
70	size_type partial_bits_to_op = ::std::min(	18✔
71	total_bits_to_op,	9✔
72	d_last.position());	27✔
73	if (partial_bits_to_op != 0) {	18!
74	advance(last, -partial_bits_to_op);	18✔
75	word_type word;	18✔
76	std::tie(word, acc) = binary_op_subword(std::move(acc), get_masked_word<word_type>(last, partial_bits_to_op), partial_bits_to_op);	18✔
77	*d_it = _bitblend(	18✔
78	*d_it,	9✔
79	word,	9✔
80	d_first.position(),	18✔
81	partial_bits_to_op);	9✔
82	total_bits_to_op -= partial_bits_to_op;	18✔
83	}	9✔
84	}	9✔
85	}	9✔
86
87
88	const size_type whole_words_to_op = total_bits_to_op / digits;	18✔
89	const size_type remaining_bits_to_op = total_bits_to_op % digits;	18✔
90
91	for (size_t i = 0; i < whole_words_to_op; i ++) {	18!
92	if constexpr (forward) {
93	word_type word;
94	std::tie(word, acc) = binary_op(std::move(acc), get_word<word_type>(first));
95	*d_it = word;
96	advance(first, digits);
97	std::advance(d_it, 1);
98	} else {
NEW 99	advance(last, -digits);	×
NEW 100	std::advance(d_it, -1);
101	word_type word;	×
102	std::tie(word, acc) = binary_op(std::move(acc), get_word<word_type>(last));	×
103	*d_it = word;	×
104	}
105	}
106	if (remaining_bits_to_op > 0) {	18!
107	if constexpr (forward) {
108	word_type word;
109	std::tie(word, acc) = binary_op_subword(std::move(acc), get_masked_word<word_type>(first, remaining_bits_to_op), remaining_bits_to_op);
110	*d_it = _bitblend(
111	*d_it,
112	word,
113	0,
114	remaining_bits_to_op);
115
116	} else {
NEW 117	advance(last, -remaining_bits_to_op);	×
NEW 118	std::advance(d_it, -1);
119	word_type word;	×
120	std::tie(word, acc) = binary_op_subword(std::move(acc), get_masked_word<word_type>(last, remaining_bits_to_op), remaining_bits_to_op);	×
121	*d_it = _bitblend(	×
122	*d_it,
123	word,
124	0,
125	remaining_bits_to_op);
126	}
127	}
128
129	return acc;	27✔
130	}	9✔
131
132	template <
133	typename RandomAccessItIn,
134	typename RandomAccessItOut,
135	typename T,
136	typename BinaryOperation,
137	typename BinaryOperationSubword>
138	requires(
139	(std::is_same_v<std::remove_cvref_t<std::iter_value_t<RandomAccessItIn>>,
140	std::remove_cvref_t<std::iter_value_t<RandomAccessItOut>>>))
141	constexpr auto transform_accumulate_backward(	9✔
142	const bit_iterator<RandomAccessItIn>& first,
143	const bit_iterator<RandomAccessItIn>& last,
144	const bit_iterator<RandomAccessItOut>& d_first,
145	const bit_iterator<RandomAccessItOut>& d_last,
146	const T& acc,
147	BinaryOperation binary_op,
148	BinaryOperationSubword binary_op_subword) {	9✔
149	return transform_accumulate<false, true>(first, last, d_first, d_last, acc, binary_op, binary_op_subword);	27✔
150	}	9✔
151
152	} // namespace bit
153
154	#endif // _BIT_TRANSFORM_ACCUMULATE_HPP_INCLUDED

PeterCDMcLean / BitLib / 16820722729

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous