Method fit

crates/openquant/src/sb_bagging.rs:137–231

(
        &mut self,
        x: &DMatrix<f64>,
        y: &[u8],
        ind_mat: &[Vec<u8>],
        sample_weight: Option<&[f64]>,
    )

    }

    pub fn fit(
        &mut self,
        x: &DMatrix<f64>,
        y: &[u8],
        ind_mat: &[Vec<u8>],
        sample_weight: Option<&[f64]>,
    ) -> Result<(), SbBaggingError> {
        if x.nrows() == 0 || x.ncols() == 0 {
            return Err(SbBaggingError::EmptyInput);
        }
        if y.len() != x.nrows() {
            return Err(SbBaggingError::DimensionMismatch);
        }
        if self.n_estimators == 0 {
            return Err(SbBaggingError::InvalidEstimators);
        }
        if !self.supports_sample_weight && sample_weight.is_some() {
            return Err(SbBaggingError::SampleWeightNotSupported);
        }
        if self.warm_start && self.oob_score {
            return Err(SbBaggingError::WarmStartWithOob);
        }

        let max_samples = validate_and_resolve_max_samples(self.max_samples, x.nrows())?;
        let max_features = validate_and_resolve_max_features(self.max_features, x.ncols())?;

        if !self.warm_start {
            self.estimators.clear();
            self.estimators_samples.clear();
        }

        let n_more = self.n_estimators as isize - self.estimators.len() as isize;
        if n_more < 0 {
            return Err(SbBaggingError::DecreasingEstimators);
        }
        if n_more == 0 {
            return Ok(());
        }

        let mut rng = StdRng::seed_from_u64(self.random_state + self.estimators.len() as u64);

        for _ in 0..(n_more as usize) {
            let features =
                sampled_features(&mut rng, x.ncols(), max_features, self.bootstrap_features);
            let warmup = warmup_indices(
                &mut rng,
                ind_mat.first().map(|r| r.len()).unwrap_or(0).max(1),
                max_samples,
            );
            let samples = seq_bootstrap(ind_mat, Some(max_samples), Some(warmup));

            let feature_idx = *features.first().ok_or(SbBaggingError::EmptyInput)?;

            let mut thr = 0.0;
            for &i in &samples {
                thr += x[(i, feature_idx)];
            }
            thr /= samples.len() as f64;