use crate::core::search::approximation_disi::ApproximationBitSetAccess;
use crate::core::search::approximation_disi::ApproximationDISI;
use crate::core::search::disi_priority_queue::DisiPriorityQueue;
use crate::core::search::disi_wrapper::DisiWrapper;
use crate::core::search::doc_id_set_iterator::BitSetIteratorAccess;
use crate::core::search::doc_id_set_iterator::DocIdSetIterator;
use crate::core::search::doc_id_set_iterator::NO_MORE_DOCS;
use crate::core::search::scorable::{ChildScorable, Scorable};
use crate::core::search::score_mode::ScoreMode;
use crate::core::search::scorer::{Scorer, TwoPhaseState};
use crate::core::search::scorer_util::ScorerUtil;
use crate::core::search::two_phase_iterator::{
TwoPhaseIterator, TwoPhaseIteratorAsDocIdSetIterator,
};
use crate::core::util::TryIntoInt;
use crate::core::util::bit_util::BitUtil;
use crate::core::util::error::lucene_error::{LuceneError, Result};
use crate::core::util::math_util::MathUtil;
use smallvec::SmallVec;
pub struct WANDScorer<S, const TOP_SCORES: bool> {
disi: TwoPhaseIteratorAsDocIdSetIterator<TwoPhaseIteratorImpl<S, TOP_SCORES>>,
}
impl<S, const TOP_SCORES: bool> WANDScorer<S, TOP_SCORES>
where
S: Scorer,
{
pub(crate) fn new(
scorers: Vec<S>,
min_should_match: i32,
score_mode: ScoreMode,
lead_cost: i64,
) -> Result<WANDScorer<S, TOP_SCORES>> {
let v = DocIdSetIteratorImpl::new(scorers, min_should_match, score_mode, lead_cost)?;
let tpi = TwoPhaseIteratorImpl::new(v);
Ok(WANDScorer {
disi: TwoPhaseIteratorAsDocIdSetIterator::new(tpi),
})
}
}
impl<S, const TOP_SCORES: bool> Scorable for WANDScorer<S, TOP_SCORES>
where
S: Scorer + 'static,
{
type Child<'a>
= &'a mut S
where
Self: 'a;
fn score(&mut self) -> Result<f32> {
let disi = &mut self.disi.two_phase_iterator.approximation;
disi.advance_all_tail()?;
let mut lead_score = disi.lead_score;
if !TOP_SCORES {
let mut cur = disi.lead;
while let Some(idx) = cur {
lead_score += disi.all_scorers[idx].scorer.score()? as f64;
cur = disi.all_scorers[idx].next;
}
}
Ok(lead_score as f32)
}
fn set_min_competitive_score(&mut self, min_score: f32) -> Result<()> {
let disi = &mut self.disi.two_phase_iterator.approximation;
debug_assert_eq!(
disi.score_mode,
ScoreMode::TopScores,
"minCompetitiveScore can only be set for ScoreMode.TOP_SCORES, but got: {:?}",
disi.score_mode
);
debug_assert!(min_score >= 0f32);
let scaled_min_score = scale_min_score(min_score, disi.scaling_factor);
debug_assert!(scaled_min_score >= disi.min_competitive_score);
disi.min_competitive_score = scaled_min_score;
Ok(())
}
fn get_children(&mut self) -> Result<Vec<ChildScorable<Self::Child<'_>>>> {
let disi = &mut self.disi.two_phase_iterator.approximation;
disi.advance_all_tail()?;
let mut current = disi.lead;
let mut scorers: SmallVec<[_; 8]> = SmallVec::with_capacity(disi.all_scorers.len());
scorers.extend(disi.all_scorers.iter_mut().map(Some));
let mut children = Vec::with_capacity(disi.freq);
while let Some(idx) = current {
let wrapper = scorers[idx]
.take()
.ok_or_else(|| LuceneError::illegal_state("duplicate WAND lead"))?;
current = wrapper.next;
children.push(ChildScorable::new(&mut wrapper.scorer, "SHOULD"));
}
Ok(children)
}
fn cost(&self) -> Result<i64> {
self.disi.cost()
}
}
impl<S, const TOP_SCORES: bool> crate::core::search::scorable::FixedScore
for WANDScorer<S, TOP_SCORES>
{
}
impl<S, const TOP_SCORES: bool> DocIdSetIterator for WANDScorer<S, TOP_SCORES>
where
S: Scorer + 'static,
{
fn doc_id(&self) -> i32 {
DocIdSetIterator::doc_id(&self.disi)
}
fn next_doc(&mut self) -> Result<i32> {
DocIdSetIterator::next_doc(&mut self.disi)
}
fn advance(&mut self, target: i32) -> Result<i32> {
DocIdSetIterator::advance(&mut self.disi, target)
}
fn slow_advance(&mut self, target: i32) -> Result<i32> {
DocIdSetIterator::slow_advance(&mut self.disi, target)
}
fn cost(&self) -> Result<i64> {
DocIdSetIterator::cost(&self.disi)
}
}
impl<S, const TOP_SCORES: bool> crate::core::search::doc_id_set_iterator::DocIdSetIteratorExtensions
for WANDScorer<S, TOP_SCORES>
where
S: Scorer + 'static,
{
}
impl<S, const TOP_SCORES: bool> crate::core::search::doc_id_set_iterator::BitSetIteratorAccess
for WANDScorer<S, TOP_SCORES>
where
S: Scorer + 'static,
{
}
impl<S, const TOP_SCORES: bool> ApproximationDISI for WANDScorer<S, TOP_SCORES>
where
S: Scorer + 'static,
{
fn approx_doc_id(&self) -> i32 {
self.disi.two_phase_iterator.approx_doc_id()
}
fn approx_next_doc(&mut self) -> Result<i32> {
self.disi.two_phase_iterator.approx_next_doc()
}
fn approx_advance(&mut self, target: i32) -> Result<i32> {
self.disi.two_phase_iterator.approx_advance(target)
}
fn approx_slow_advance(&mut self, target: i32) -> Result<i32> {
self.disi.two_phase_iterator.approx_slow_advance(target)
}
fn approx_cost(&self) -> Result<i64> {
self.disi.two_phase_iterator.approx_cost()
}
}
impl<S, const TOP_SCORES: bool> ApproximationBitSetAccess for WANDScorer<S, TOP_SCORES>
where
S: Scorer + 'static,
{
fn approx_is_bit_iter(&self) -> bool {
self.disi.two_phase_iterator.approx_is_bit_iter()
}
fn approx_get(&self, index: usize) -> Result<bool> {
self.disi.two_phase_iterator.approx_get(index)
}
fn approx_set_doc_id(&mut self, doc: i32) -> Result<()> {
self.disi.two_phase_iterator.approx_set_doc_id(doc)
}
fn approx_bit_set_length(&self) -> Result<usize> {
self.disi.two_phase_iterator.approx_bit_set_length()
}
}
impl<S, const TOP_SCORES: bool> TwoPhaseIterator for WANDScorer<S, TOP_SCORES>
where
S: Scorer + 'static,
{
fn matches(&mut self) -> Result<bool> {
self.disi.two_phase_iterator.matches()
}
fn match_cost(&self) -> f32 {
self.disi.two_phase_iterator.match_cost()
}
}
impl<S, const TOP_SCORES: bool> Scorer for WANDScorer<S, TOP_SCORES>
where
S: Scorer + 'static,
{
fn scoring_doc_id(&mut self) -> Result<i32> {
Ok(self.disi.two_phase_iterator.approximation.doc)
}
fn advance_shallow(&mut self, target: i32) -> Result<i32> {
let disi = &mut self.disi.two_phase_iterator.approximation;
for w in &mut disi.all_scorers {
if w.scorer.scoring_doc_id()? < target {
w.scorer.advance_shallow(target)?;
}
}
if target <= disi.upto {
return Ok(disi.upto);
}
Ok(NO_MORE_DOCS)
}
fn get_max_score(&mut self, upto: i32) -> Result<f32> {
let all_scorers = self
.disi
.two_phase_iterator
.approximation
.all_scorers
.as_mut();
let mut max_score_sum = 0f64;
let len = all_scorers.len();
for w in all_scorers {
let scorer = &mut w.scorer;
if scorer.scoring_doc_id()? <= upto {
max_score_sum += scorer.get_max_score(upto)? as f64;
}
}
Ok(MathUtil::sum_upper_bound(max_score_sum, len.try_convert()?) as f32)
}
fn has_two_phase_iterator(&self) -> TwoPhaseState {
TwoPhaseState::Yes
}
}
pub struct DocIdSetIteratorImpl<S, const TOP_SCORES: bool> {
all_scorers: Box<[DisiWrapper<S>]>,
doc: i32,
score_mode: ScoreMode,
upto: i32,
pub(crate) head: DisiPriorityQueue,
pub(crate) lead: Option<usize>,
pub(crate) freq: usize,
pub(crate) lead_cost: i64,
pub(crate) lead_score: f64,
pub(crate) tail: Vec<usize>,
pub(crate) tail_max_score: i64,
pub(crate) tail_size: usize,
min_competitive_score: i64,
pub(crate) min_should_match: usize,
pub(crate) cost: i64,
scaling_factor: i32,
}
impl<S, const TOP_SCORES: bool> DocIdSetIteratorImpl<S, TOP_SCORES>
where
S: Scorer,
{
fn new(
mut scorers: Vec<S>,
min_should_match: i32,
score_mode: ScoreMode,
lead_cost: i64,
) -> Result<DocIdSetIteratorImpl<S, TOP_SCORES>> {
debug_assert_eq!(TOP_SCORES, score_mode == ScoreMode::TopScores);
let num_scorers = scorers.len();
if i64::from(min_should_match) >= num_scorers as i64 {
return Err(LuceneError::illegal_argument(
"minShouldMatch should be < the number of scorers",
));
}
debug_assert!(
min_should_match >= 0,
"minShouldMatch should not be negative, but got {}",
min_should_match
);
let scaling_factor = if TOP_SCORES {
let mut max_score_sum_double = 0f64;
for scorer in scorers.iter_mut() {
scorer.advance_shallow(0)?;
let max_score = scorer.get_max_score(NO_MORE_DOCS)?;
max_score_sum_double += max_score as f64;
}
let max_score_sum = MathUtil::sum_upper_bound(max_score_sum_double, num_scorers as i32);
scaling_factor(max_score_sum as f32)?
} else {
0
};
let mut all_scorers = Vec::with_capacity(num_scorers);
let mut cost: SmallVec<[i64; 8]> = SmallVec::with_capacity(num_scorers);
for scorer in scorers {
cost.push(DocIdSetIterator::cost(&scorer)?);
all_scorers.push(DisiWrapper::new(scorer)?);
}
let head = DisiPriorityQueue::new(num_scorers);
let tail = vec![0usize; num_scorers];
let min_should_match: usize = min_should_match.try_convert()?;
let mut this = Self {
all_scorers: all_scorers.into_boxed_slice(),
doc: -1,
score_mode,
upto: -1,
head,
lead: None,
freq: 0,
lead_cost,
lead_score: 0.0,
tail,
tail_max_score: 0,
tail_size: 0,
min_competitive_score: 0,
min_should_match,
cost: 0,
scaling_factor,
};
for idx in 0..num_scorers {
this.add_unpositioned_lead(idx);
}
this.cost = ScorerUtil::cost_with_min_should_match(cost, num_scorers, min_should_match)?;
Ok(this)
}
fn add_lead(&mut self, lead_idx: usize) -> Result<()> {
self.all_scorers[lead_idx].next = self.lead;
self.lead = Some(lead_idx);
self.freq += 1;
if TOP_SCORES {
let scorer = self.all_scorers[lead_idx].scorer.score()?;
self.lead_score += scorer as f64;
}
Ok(())
}
fn add_unpositioned_lead(&mut self, lead_idx: usize) {
debug_assert!(self.all_scorers[lead_idx].doc == -1);
self.all_scorers[lead_idx].next = self.lead;
self.lead = Some(lead_idx);
self.freq += 1;
}
fn push_back_leads(&mut self, target: i32) -> Result<()> {
let mut cur = self.lead;
while let Some(idx) = cur {
let evicted = self.insert_tail_with_overflow(idx);
if let Some(evicted_idx) = evicted {
let new_doc = self.all_scorers[evicted_idx].scorer.advance(target)?;
self.all_scorers[evicted_idx].doc = new_doc;
self.head.add(evicted_idx, &self.all_scorers);
}
cur = self.all_scorers[idx].next;
}
self.lead = None;
Ok(())
}
fn advance_head(&mut self, target: i32) -> Result<Option<usize>> {
let mut head_top = self.head.top();
while let Some(ref top_idx) = head_top {
let top_idx = *top_idx;
if self.all_scorers[top_idx].doc >= target {
break;
}
let evicted = self.insert_tail_with_overflow(top_idx);
if let Some(evicted_idx) = evicted {
let new_doc = self.all_scorers[evicted_idx].scorer.advance(target)?;
self.all_scorers[evicted_idx].doc = new_doc;
head_top = Some(self.head.update_top_with(evicted_idx, &self.all_scorers));
} else {
self.head.pop(&self.all_scorers);
head_top = self.head.top();
}
}
Ok(head_top)
}
fn advance_tail(&mut self, idx: usize) -> Result<()> {
let new_doc = self.all_scorers[idx].scorer.advance(self.doc)?;
self.all_scorers[idx].doc = new_doc;
if new_doc == self.doc {
self.add_lead(idx)?;
} else {
self.head.add(idx, &self.all_scorers);
}
Ok(())
}
fn advance_tail_top(&mut self) -> Result<()> {
let top = self.pop_tail();
self.advance_tail(top)
}
fn update_max_scores(&mut self, target: i32) -> Result<()> {
let mut new_upto = NO_MORE_DOCS;
{
let iter = self.head.iter();
for idx in iter {
let w = &mut self.all_scorers[idx];
if w.doc <= new_upto && w.cost <= self.lead_cost {
let shallow = w.scorer.advance_shallow(w.doc)?;
new_upto = new_upto.min(shallow);
}
}
}
if new_upto == NO_MORE_DOCS
&& self.tail_size > 0
&& self.all_scorers[self.tail[0]].cost <= self.lead_cost
{
let top_idx = self.tail[0];
new_upto = self.all_scorers[top_idx].scorer.advance_shallow(target)?;
if let Some(ht) = self.head.top() {
new_upto = new_upto.max(self.all_scorers[ht].doc);
}
}
self.upto = new_upto;
{
let iter = self.head.iter();
for idx in iter {
let w = &mut self.all_scorers[idx];
if w.doc <= self.upto {
let v = w.scorer.get_max_score(new_upto)?;
w.scaled_max_score = scale_max_score(v, self.scaling_factor);
}
}
}
self.tail_max_score = 0;
for i in 0..self.tail_size {
let idx = self.tail[i];
let w = &mut self.all_scorers[idx];
w.scorer.advance_shallow(target)?;
let v = w.scorer.get_max_score(self.upto)?;
w.scaled_max_score = scale_max_score(v, self.scaling_factor);
Self::up_heap_max_score(&mut self.tail, i, &self.all_scorers);
self.tail_max_score += self.all_scorers[idx].scaled_max_score;
}
while self.tail_size > 0 && self.tail_max_score >= self.min_competitive_score {
let idx = self.pop_tail();
let new_doc = self.all_scorers[idx].scorer.advance(target)?;
self.all_scorers[idx].doc = new_doc;
self.head.add(idx, &self.all_scorers);
}
Ok(())
}
fn move_to_next_block(&mut self, mut target: i32) -> Result<()> {
debug_assert!(self.lead.is_none());
while self.upto < NO_MORE_DOCS {
if self.head.size() == 0 {
target = target.max(self.upto + 1);
self.update_max_scores(target)?;
} else {
let top_idx = self
.head
.top()
.ok_or_else(|| LuceneError::illegal_state("no top available"))?;
let top_doc = self.all_scorers[top_idx].doc;
if top_doc > self.upto {
debug_assert!(top_doc >= target);
self.update_max_scores(target)?;
break;
} else {
break;
}
}
}
debug_assert!(
self
.head
.top()
.is_none_or(|idx| self.all_scorers[idx].doc <= self.upto)
);
debug_assert!(self.upto >= target);
Ok(())
}
fn move_to_next_candidate(&mut self) -> Result<()> {
let lead_idx = self.head.pop(&self.all_scorers);
self.lead = Some(lead_idx);
debug_assert!(self.doc == self.all_scorers[lead_idx].doc);
self.all_scorers[lead_idx].next = None;
self.freq = 1;
if TOP_SCORES {
self.lead_score = self.all_scorers[lead_idx].scorer.score()? as f64;
}
while self.head.size() > 0 {
let top_idx = match self.head.top() {
Some(idx) => idx,
None => return Err(LuceneError::illegal_state("head top is empty")),
};
if self.all_scorers[top_idx].doc != self.doc {
break;
}
let popped = self.head.pop(&self.all_scorers);
self.add_lead(popped)?;
}
Ok(())
}
fn advance_all_tail(&mut self) -> Result<()> {
for i in (0..self.tail_size).rev() {
self.advance_tail(self.tail[i])?;
}
self.tail_size = 0;
self.tail_max_score = 0;
debug_assert!(self.ensure_consistent()?);
Ok(())
}
fn insert_tail_with_overflow(&mut self, s: usize) -> Option<usize> {
let s_score = self.all_scorers[s].scaled_max_score;
if self.tail_max_score + s_score < self.min_competitive_score
|| self.tail_size + 1 < self.min_should_match
{
self.add_tail(s);
self.tail_max_score += s_score;
None
} else if self.tail_size == 0 {
Some(s)
} else {
let top = self.tail[0];
if !Self::greater_max_score(&self.all_scorers[top], &self.all_scorers[s]) {
Some(s)
} else {
self.tail[0] = s;
Self::down_heap_max_score(&mut self.tail, self.tail_size, &self.all_scorers);
self.tail_max_score =
self.tail_max_score - self.all_scorers[top].scaled_max_score + s_score;
Some(top)
}
}
}
fn add_tail(&mut self, idx: usize) {
self.tail[self.tail_size] = idx;
Self::up_heap_max_score(&mut self.tail, self.tail_size, &self.all_scorers);
self.tail_size += 1;
}
fn pop_tail(&mut self) -> usize {
debug_assert!(self.tail_size > 0);
let result = self.tail[0];
self.tail_size -= 1;
self.tail[0] = self.tail[self.tail_size];
Self::down_heap_max_score(&mut self.tail, self.tail_size, &self.all_scorers);
self.tail_max_score -= self.all_scorers[result].scaled_max_score;
result
}
fn up_heap_max_score(heap: &mut [usize], mut i: usize, all: &[DisiWrapper<S>]) {
let node = heap[i];
while let Some(j) = DisiPriorityQueue::parent_node(i) {
if !Self::greater_max_score(&all[node], &all[heap[j]]) {
break;
}
heap[i] = heap[j];
i = j;
}
heap[i] = node;
}
fn down_heap_max_score(heap: &mut [usize], size: usize, all: &[DisiWrapper<S>]) {
let mut i = 0;
let node = heap[0];
let mut j = DisiPriorityQueue::left_node(i);
if j < size {
let mut k = DisiPriorityQueue::right_node(j);
if k < size && Self::greater_max_score(&all[heap[k]], &all[heap[j]]) {
j = k;
}
if Self::greater_max_score(&all[heap[j]], &all[node]) {
loop {
heap[i] = heap[j];
i = j;
j = DisiPriorityQueue::left_node(i);
k = DisiPriorityQueue::right_node(j);
if k < size && Self::greater_max_score(&all[heap[k]], &all[heap[j]]) {
j = k;
}
if j >= size || !Self::greater_max_score(&all[heap[j]], &all[node]) {
break;
}
}
heap[i] = node;
}
}
}
fn greater_max_score(w1: &DisiWrapper<S>, w2: &DisiWrapper<S>) -> bool {
if w1.scaled_max_score > w2.scaled_max_score {
true
} else if w1.scaled_max_score < w2.scaled_max_score {
false
} else {
w1.cost < w2.cost
}
}
fn ensure_consistent(&mut self) -> Result<bool> {
if TOP_SCORES {
let mut max_score_sum: i64 = 0;
for i in 0..self.tail_size {
let idx = self.tail[i];
let w = &self.all_scorers[idx];
debug_assert!(w.doc < self.doc);
max_score_sum = max_score_sum
.checked_add(w.scaled_max_score)
.ok_or_else(|| LuceneError::number_overflow("scaled maximum score sum overflowed"))?;
}
debug_assert!(
max_score_sum == self.tail_max_score,
"tailMaxScore mismatch: {max_score_sum} vs {}",
self.tail_max_score
);
let mut lead_scores: Vec<f32> = Vec::with_capacity(self.freq);
let mut cur = self.lead;
while let Some(idx) = cur {
let w = &mut self.all_scorers[idx];
debug_assert!(w.doc == self.doc);
lead_scores.push(w.scorer.score()?);
cur = w.next;
}
lead_scores.reverse();
let mut recomputed_lead_score = 0f64;
for score in &lead_scores {
recomputed_lead_score += *score as f64;
}
debug_assert!(
(recomputed_lead_score == self.lead_score),
"leadScore mismatch: recomputed={recomputed_lead_score} stored={}",
self.lead_score
);
debug_assert!(
self.min_competitive_score == 0
|| self.tail_max_score < self.min_competitive_score
|| self.tail_size < self.min_should_match,
);
debug_assert!(self.doc <= self.upto);
}
let head_iter = self.head.iter();
for idx in head_iter {
let w = &self.all_scorers[idx];
if self.lead.is_none() {
debug_assert!(w.doc >= self.doc);
} else {
debug_assert!(w.doc > self.doc);
}
}
Ok(true)
}
}
impl<S, const TOP_SCORES: bool> crate::core::search::doc_id_set_iterator::DocIdSetIteratorExtensions
for DocIdSetIteratorImpl<S, TOP_SCORES>
where
S: Scorer,
{
}
impl<S, const TOP_SCORES: bool> crate::core::search::doc_id_set_iterator::BitSetIteratorAccess
for DocIdSetIteratorImpl<S, TOP_SCORES>
where
S: Scorer,
{
}
impl<S, const TOP_SCORES: bool> DocIdSetIterator for DocIdSetIteratorImpl<S, TOP_SCORES>
where
S: Scorer,
{
fn doc_id(&self) -> i32 {
self.doc
}
fn next_doc(&mut self) -> Result<i32> {
self.advance(self.doc + 1)
}
fn advance(&mut self, target: i32) -> Result<i32> {
self.push_back_leads(target)?;
let mut head_top = self.advance_head(target)?;
if TOP_SCORES && head_top.is_none_or(|idx| self.all_scorers[idx].doc > self.upto) {
self.move_to_next_block(target)?;
debug_assert!(self.upto >= target);
head_top = self.head.top();
}
if let Some(idx) = head_top {
self.doc = self.all_scorers[idx].doc;
Ok(self.doc)
} else {
self.doc = NO_MORE_DOCS;
Ok(self.doc)
}
}
fn cost(&self) -> Result<i64> {
Ok(self.cost)
}
}
pub struct TwoPhaseIteratorImpl<S, const TOP_SCORES: bool> {
approximation: DocIdSetIteratorImpl<S, TOP_SCORES>,
}
impl<S, const TOP_SCORES: bool> TwoPhaseIteratorImpl<S, TOP_SCORES> {
pub fn new(approximation: DocIdSetIteratorImpl<S, TOP_SCORES>) -> Self {
Self { approximation }
}
}
impl<S, const TOP_SCORES: bool> ApproximationDISI for TwoPhaseIteratorImpl<S, TOP_SCORES>
where
S: Scorer,
{
fn approx_doc_id(&self) -> i32 {
self.approximation.doc_id()
}
fn approx_next_doc(&mut self) -> Result<i32> {
self.approximation.next_doc()
}
fn approx_advance(&mut self, target: i32) -> Result<i32> {
self.approximation.advance(target)
}
fn approx_slow_advance(&mut self, target: i32) -> Result<i32> {
self.approximation.slow_advance(target)
}
fn approx_cost(&self) -> Result<i64> {
self.approximation.cost()
}
}
impl<S, const TOP_SCORES: bool> ApproximationBitSetAccess for TwoPhaseIteratorImpl<S, TOP_SCORES>
where
S: Scorer,
{
fn approx_is_bit_iter(&self) -> bool {
self.approximation.is_bit_iter()
}
fn approx_get(&self, index: usize) -> Result<bool> {
self.approximation.get(index)
}
fn approx_set_doc_id(&mut self, doc: i32) -> Result<()> {
self.approximation.set_doc_id(doc)
}
fn approx_bit_set_length(&self) -> Result<usize> {
self.approximation.bit_set_length()
}
}
impl<S, const TOP_SCORES: bool> TwoPhaseIterator for TwoPhaseIteratorImpl<S, TOP_SCORES>
where
S: Scorer,
{
fn matches(&mut self) -> Result<bool> {
let approx = &mut self.approximation;
debug_assert!(approx.lead.is_none());
approx.move_to_next_candidate()?;
let mut scaled_lead_score: i64 = 0;
if TOP_SCORES {
scaled_lead_score = scale_max_score(
MathUtil::sum_upper_bound(approx.lead_score, FLOAT_MANTISSA_BITS) as f32,
approx.scaling_factor,
);
}
while scaled_lead_score < approx.min_competitive_score || approx.freq < approx.min_should_match
{
debug_assert!(approx.ensure_consistent()?);
if scaled_lead_score + approx.tail_max_score < approx.min_competitive_score
|| approx.freq + approx.tail_size < approx.min_should_match
{
return Ok(false);
} else {
let prev_lead = approx.lead;
approx.advance_tail_top()?;
if TOP_SCORES && approx.lead != prev_lead {
debug_assert!(match approx.lead {
Some(lead) => prev_lead == approx.all_scorers[lead].next,
None => false,
});
scaled_lead_score = scale_max_score(
MathUtil::sum_upper_bound(approx.lead_score, FLOAT_MANTISSA_BITS) as f32,
approx.scaling_factor,
);
}
}
}
debug_assert!(approx.ensure_consistent()?);
Ok(true)
}
fn match_cost(&self) -> f32 {
self.approximation.tail.len() as f32
}
}
pub(crate) const FLOAT_MANTISSA_BITS: i32 = 24;
const MAX_SCALED_SCORE: i64 = (1_i64 << 24) - 1;
pub(crate) fn scaling_factor(f: f32) -> Result<i32> {
if f < 0.0 {
Err(LuceneError::illegal_argument(
"Scores must be positive or null",
))
} else if f == 0.0 {
Ok(scaling_factor(BitUtil::F32_MIN_VALUE)? + 1)
} else if f.is_infinite() {
Ok(scaling_factor(f32::MAX)? - 1)
} else {
let d = f as f64;
let exp = ((d.to_bits() >> 52) & 0x7ff) as i32 - 1023;
debug_assert!(d == 0.0 || exp >= -1022);
Ok(FLOAT_MANTISSA_BITS - 1 - exp)
}
}
pub(crate) fn scale_max_score(max_score: f32, scaling_factor: i32) -> i64 {
debug_assert!(!max_score.is_nan());
debug_assert!(max_score >= 0.0);
let scaled = (max_score as f64) * (2f64.powi(scaling_factor));
if scaled > MAX_SCALED_SCORE as f64 {
return MAX_SCALED_SCORE;
}
scaled.ceil() as i64
}
fn scale_min_score(min_score: f32, scaling_factor: i32) -> i64 {
debug_assert!(min_score.is_finite());
debug_assert!(min_score >= 0.0);
let scaled = (min_score as f64) * (2f64.powi(scaling_factor));
scaled.floor() as i64
}