20 #ifndef FST_INTERVAL_SET_H_ 21 #define FST_INTERVAL_SET_H_ 24 #include <initializer_list> 44 bool operator<(const IntInterval<T> &i)
const {
45 return begin < i.begin || (begin == i.begin && end > i.end);
49 return begin == i.
begin && end == i.
end;
53 return begin != i.
begin || end != i.
end;
56 std::istream &
Read(std::istream &strm) {
65 std::ostream &
Write(std::ostream &strm)
const {
80 using Iterator =
typename std::vector<Interval>::const_iterator;
84 : intervals_(intervals_init), count_(-1) {}
90 T
Size()
const {
return intervals_.size(); }
92 T
Count()
const {
return count_; }
105 std::istream &
Read(std::istream &strm) {
110 std::ostream &
Write(std::ostream &strm)
const {
116 std::vector<Interval> intervals_;
122 template <
class T,
class Store = VectorIntervalStore<T>>
128 : intervals_(intervals_init) {}
130 template <
class... A>
135 return intervals_.MutableIntervals();
141 bool Empty()
const {
return Size() == 0; }
143 T
Size()
const {
return intervals_.Size(); }
146 T
Count()
const {
return intervals_.Count(); }
148 void Clear() { intervals_.Clear(); }
152 intervals_.MutableIntervals()->insert(intervals_.MutableIntervals()->end(),
153 iset.intervals_.begin(),
154 iset.intervals_.end());
159 const Interval interval(value, value);
160 auto lb = std::lower_bound(intervals_.begin(), intervals_.end(), interval);
161 if (lb == intervals_.begin())
return false;
162 return (--lb)->end > value;
167 return Size() == iset.
Size() &&
168 std::equal(intervals_.begin(), intervals_.end(),
169 iset.intervals_.begin());
174 return Size() != iset.
Size() ||
175 !std::equal(intervals_.begin(), intervals_.end(),
176 iset.intervals_.begin());
180 return Size() == 1 &&
181 intervals_.begin()->begin + 1 == intervals_.begin()->end;
213 std::istream &
Read(std::istream &strm) {
return intervals_.Read(strm); }
215 std::ostream &
Write(std::ostream &strm)
const {
216 return intervals_.Write(strm);
219 typename Store::Iterator
begin()
const {
return intervals_.begin(); }
221 typename Store::Iterator
end()
const {
return intervals_.end(); }
228 template <
typename T,
class Store>
230 auto &intervals = *intervals_.MutableIntervals();
231 std::sort(intervals.begin(), intervals.end());
234 for (T i = 0; i < intervals.size(); ++i) {
235 auto &inti = intervals[i];
236 if (inti.begin == inti.end)
continue;
237 for (T j = i + 1; j < intervals.size(); ++j) {
238 auto &intj = intervals[j];
239 if (intj.begin > inti.end)
break;
240 if (intj.end > inti.end) inti.end = intj.end;
243 count += inti.end - inti.begin;
244 intervals[size++] = inti;
246 intervals.resize(size);
247 intervals_.SetCount(count);
252 template <
typename T,
class Store>
256 auto it1 = intervals_.begin();
257 auto it2 = iset.intervals_.begin();
260 while (it1 != intervals_.end() && it2 != iset.intervals_.end()) {
261 if (it1->end <= it2->begin) {
263 }
else if (it2->end <= it1->begin) {
266 ointervals->emplace_back(std::max(it1->begin, it2->begin),
267 std::min(it1->end, it2->end));
268 count += ointervals->back().end - ointervals->back().begin;
269 if (it1->end < it2->end) {
276 oset->intervals_.SetCount(count);
281 template <
typename T,
class Store>
289 for (
const auto current_interval : intervals_) {
290 interval.
end = std::min(current_interval.begin, maxval);
291 if ((interval.
begin) < (interval.
end)) {
292 ointervals->push_back(interval);
293 count += interval.
end - interval.
begin;
295 interval.
begin = current_interval.end;
297 interval.
end = maxval;
298 if ((interval.
begin) < (interval.
end)) {
299 ointervals->push_back(interval);
300 count += interval.
end - interval.
begin;
302 oset->intervals_.SetCount(count);
307 template <
typename T,
class Store>
312 oset->intervals_.SetCount(0);
315 iset.
Complement(intervals_.Intervals()[intervals_.Size() - 1].end, &cset);
322 template <
typename T,
class Store>
324 auto it1 = intervals_.begin();
325 auto it2 = iset.intervals_.begin();
326 while (it1 != intervals_.end() && it2 != iset.intervals_.end()) {
327 if (it1->end <= it2->begin) {
329 }
else if (it2->end <= it1->begin) {
340 template <
typename T,
class Store>
343 auto it1 = intervals_.begin();
344 auto it2 = iset.intervals_.begin();
347 bool overlap =
false;
348 while (it1 != intervals_.end() && it2 != iset.intervals_.end()) {
349 if (it1->end <= it2->begin) {
352 }
else if (it2->end <= it1->begin) {
355 }
else if (it2->begin == it1->begin && it2->end == it1->end) {
359 }
else if (it2->begin <= it1->begin && it2->end >= it1->end) {
363 }
else if (it1->begin <= it2->begin && it1->end >= it2->end) {
372 if (only1 ==
true && only2 ==
true && overlap ==
true)
return true;
374 if (it1 != intervals_.end()) only1 =
true;
375 if (it2 != iset.intervals_.end()) only2 =
true;
376 return only1 ==
true && only2 ==
true && overlap ==
true;
381 template <
typename T,
class Store>
383 if (iset.
Count() > Count())
return false;
384 auto it1 = intervals_.begin();
385 auto it2 = iset.intervals_.begin();
386 while (it1 != intervals_.end() && it2 != iset.intervals_.end()) {
387 if ((it1->end) <= (it2->begin)) {
389 }
else if ((it2->begin) < (it1->begin) ||
390 (it2->end) > (it1->end)) {
392 }
else if (it2->end == it1->end) {
399 return it2 == iset.intervals_.end();
402 template <
typename T,
class Store>
403 std::ostream &operator<<(std::ostream &strm, const IntervalSet<T, Store> &s) {
405 for (T i = 0; i < s.Size(); ++i) {
409 const auto &interval = s.Intervals()[i];
410 strm <<
"[" << interval.begin <<
"," << interval.end <<
")";
418 #endif // FST_INTERVAL_SET_H_
bool operator!=(const IntervalSet< T, Store > &iset) const
void Union(const IntervalSet< T, Store > &iset)
std::istream & Read(std::istream &strm)
VectorIntervalStore(std::initializer_list< Interval > intervals_init)
std::istream & Read(std::istream &strm)
IntInterval(T begin, T end)
bool operator==(const IntInterval< T > &i) const
void Intersect(const Fst< Arc > &ifst1, const Fst< Arc > &ifst2, MutableFst< Arc > *ofst, const IntersectOptions &opts=IntersectOptions())
const Interval * Intervals() const
std::vector< Interval > * MutableIntervals()
std::ostream & Write(std::ostream &strm) const
void Intersect(const IntervalSet< T, Store > &iset, IntervalSet< T, Store > *oset) const
void Complement(T maxval, IntervalSet< T, Store > *oset) const
std::ostream & WriteType(std::ostream &strm, const T t)
void Difference(const Fst< Arc > &ifst1, const Fst< Arc > &ifst2, MutableFst< Arc > *ofst, const DifferenceOptions &opts=DifferenceOptions())
std::istream & Read(std::istream &strm)
std::ostream & Write(std::ostream &strm) const
bool Member(T value) const
bool StrictlyOverlaps(const IntervalSet< T, Store > &iset) const
typename std::vector< Interval >::const_iterator Iterator
IntervalSet(std::initializer_list< Interval > intervals_init)
Store::Iterator begin() const
std::vector< Interval > * MutableIntervals()
std::ostream & Write(std::ostream &strm) const
void Difference(const IntervalSet< T, Store > &iset, IntervalSet< T, Store > *oset) const
Store::Iterator end() const
const Interval * Intervals() const
std::istream & ReadType(std::istream &strm, T *t)
bool Overlaps(const IntervalSet< T, Store > &iset) const
bool operator!=(const IntInterval< T > &i) const
bool Contains(const IntervalSet< T, Store > &iset) const
bool operator==(const IntervalSet< T, Store > &iset) const