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
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
|
/* SPDX-License-Identifier: MIT */
/* Copyright © 2021 Max Bachmann */
#pragma once
#include <limits>
#include <rapidfuzz/details/common.hpp>
#include <rapidfuzz/distance/Hamming_impl.hpp>
namespace rapidfuzz {
/**
* @brief Calculates the Hamming distance between two strings.
*
* @details
* Both strings require a similar length
*
*
* @tparam Sentence1 This is a string that can be converted to
* basic_string_view<char_type>
* @tparam Sentence2 This is a string that can be converted to
* basic_string_view<char_type>
*
* @param s1
* string to compare with s2 (for type info check Template parameters above)
* @param s2
* string to compare with s1 (for type info check Template parameters above)
* @param max
* Maximum Hamming distance between s1 and s2, that is
* considered as a result. If the distance is bigger than max,
* max + 1 is returned instead. Default is std::numeric_limits<size_t>::max(),
* which deactivates this behaviour.
*
* @return Hamming distance between s1 and s2
*/
template <typename InputIt1, typename InputIt2>
size_t hamming_distance(InputIt1 first1, InputIt1 last1, InputIt2 first2, InputIt2 last2, bool pad_ = true,
size_t score_cutoff = std::numeric_limits<size_t>::max())
{
return detail::Hamming::distance(first1, last1, first2, last2, pad_, score_cutoff, score_cutoff);
}
template <typename Sentence1, typename Sentence2>
size_t hamming_distance(const Sentence1& s1, const Sentence2& s2, bool pad_ = true,
size_t score_cutoff = std::numeric_limits<size_t>::max())
{
return detail::Hamming::distance(s1, s2, pad_, score_cutoff, score_cutoff);
}
template <typename InputIt1, typename InputIt2>
size_t hamming_similarity(InputIt1 first1, InputIt1 last1, InputIt2 first2, InputIt2 last2, bool pad_ = true,
size_t score_cutoff = 0)
{
return detail::Hamming::similarity(first1, last1, first2, last2, pad_, score_cutoff, score_cutoff);
}
template <typename Sentence1, typename Sentence2>
size_t hamming_similarity(const Sentence1& s1, const Sentence2& s2, bool pad_ = true, size_t score_cutoff = 0)
{
return detail::Hamming::similarity(s1, s2, pad_, score_cutoff, score_cutoff);
}
template <typename InputIt1, typename InputIt2>
double hamming_normalized_distance(InputIt1 first1, InputIt1 last1, InputIt2 first2, InputIt2 last2,
bool pad_ = true, double score_cutoff = 1.0)
{
return detail::Hamming::normalized_distance(first1, last1, first2, last2, pad_, score_cutoff,
score_cutoff);
}
template <typename Sentence1, typename Sentence2>
double hamming_normalized_distance(const Sentence1& s1, const Sentence2& s2, bool pad_ = true,
double score_cutoff = 1.0)
{
return detail::Hamming::normalized_distance(s1, s2, pad_, score_cutoff, score_cutoff);
}
template <typename InputIt1, typename InputIt2>
Editops hamming_editops(InputIt1 first1, InputIt1 last1, InputIt2 first2, InputIt2 last2, bool pad_ = true,
size_t score_hint = std::numeric_limits<size_t>::max())
{
return detail::hamming_editops(detail::make_range(first1, last1), detail::make_range(first2, last2), pad_,
score_hint);
}
template <typename Sentence1, typename Sentence2>
Editops hamming_editops(const Sentence1& s1, const Sentence2& s2, bool pad_ = true,
size_t score_hint = std::numeric_limits<size_t>::max())
{
return detail::hamming_editops(detail::make_range(s1), detail::make_range(s2), pad_, score_hint);
}
/**
* @brief Calculates a normalized hamming similarity
*
* @details
* Both string require a similar length
*
*
* @tparam Sentence1 This is a string that can be converted to
* basic_string_view<char_type>
* @tparam Sentence2 This is a string that can be converted to
* basic_string_view<char_type>
*
* @param s1
* string to compare with s2 (for type info check Template parameters above)
* @param s2
* string to compare with s1 (for type info check Template parameters above)
* @param score_cutoff
* Optional argument for a score threshold as a float between 0 and 1.0.
* For ratio < score_cutoff 0 is returned instead. Default is 0,
* which deactivates this behaviour.
*
* @return Normalized hamming distance between s1 and s2
* as a float between 0 and 1.0
*/
template <typename InputIt1, typename InputIt2>
double hamming_normalized_similarity(InputIt1 first1, InputIt1 last1, InputIt2 first2, InputIt2 last2,
bool pad_ = true, double score_cutoff = 0.0)
{
return detail::Hamming::normalized_similarity(first1, last1, first2, last2, pad_, score_cutoff,
score_cutoff);
}
template <typename Sentence1, typename Sentence2>
double hamming_normalized_similarity(const Sentence1& s1, const Sentence2& s2, bool pad_ = true,
double score_cutoff = 0.0)
{
return detail::Hamming::normalized_similarity(s1, s2, pad_, score_cutoff, score_cutoff);
}
template <typename CharT1>
struct CachedHamming : public detail::CachedDistanceBase<CachedHamming<CharT1>, size_t, 0,
std::numeric_limits<int64_t>::max()> {
template <typename Sentence1>
explicit CachedHamming(const Sentence1& s1_, bool pad_ = true)
: CachedHamming(detail::to_begin(s1_), detail::to_end(s1_), pad_)
{}
template <typename InputIt1>
CachedHamming(InputIt1 first1, InputIt1 last1, bool pad_ = true) : s1(first1, last1), pad(pad_)
{}
private:
friend detail::CachedDistanceBase<CachedHamming<CharT1>, size_t, 0, std::numeric_limits<int64_t>::max()>;
friend detail::CachedNormalizedMetricBase<CachedHamming<CharT1>>;
template <typename InputIt2>
size_t maximum(const detail::Range<InputIt2>& s2) const
{
return std::max(s1.size(), s2.size());
}
template <typename InputIt2>
size_t _distance(const detail::Range<InputIt2>& s2, size_t score_cutoff, size_t score_hint) const
{
return detail::Hamming::distance(s1, s2, pad, score_cutoff, score_hint);
}
std::vector<CharT1> s1;
bool pad;
};
#ifdef RAPIDFUZZ_DEDUCTION_GUIDES
template <typename Sentence1>
explicit CachedHamming(const Sentence1& s1_, bool pad_ = true) -> CachedHamming<char_type<Sentence1>>;
template <typename InputIt1>
CachedHamming(InputIt1 first1, InputIt1 last1, bool pad_ = true) -> CachedHamming<iter_value_t<InputIt1>>;
#endif
/**@}*/
} // namespace rapidfuzz
|
