Struct RcfConfig 

#[non_exhaustive]
pub struct RcfConfig {
    pub num_trees: usize,
    pub sample_size: usize,
    pub time_decay: f64,
    pub seed: Option<u64>,
    pub num_threads: Option<usize>,
    pub initial_accept_fraction: f64,
    pub feature_scales: Option<Vec<f64>>,
}

Validated forest hyperparameters (dimension is encoded separately at the type level).

Examples

use anomstream_core::{ForestBuilder, RcfConfig};

let builder = ForestBuilder::<4>::new()
    .num_trees(50)
    .sample_size(64);
let cfg: &RcfConfig = builder.config();
assert_eq!(cfg.num_trees, 50);
cfg.validate().unwrap();

Fields (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

num_trees: usize

Number of trees in the forest (num_trees).

sample_size: usize

Maximum reservoir size per tree (num_samples_per_tree).

time_decay: f64

Time-decay factor applied to reservoir sampling weights. A value of 0.0 restores strict uniform sampling; positive values bias the reservoir toward recent points. Default resolved by ForestBuilder is 0.1 / sample_size, matching the AWS Java CompactSampler reference.

seed: Option<u64>

Optional deterministic seed; None falls back to entropy.

num_threads: Option<usize>

Optional dedicated rayon thread pool size for the parallel cargo feature. None means “use rayon’s global pool” (configurable via the RAYON_NUM_THREADS env var). Some(n) builds a per-forest rayon::ThreadPool of n workers so callers can isolate this forest from the rest of the application’s rayon workload. Ignored without parallel.

initial_accept_fraction: f64

Warmup admission fraction forwarded to every per-tree crate::ReservoirSampler. See that type’s module-level docs for semantics. 1.0 disables the gate; smaller values ramp admission during the cold-start period so the reservoir is less dominated by the first few stream entries.

feature_scales: Option<Vec<f64>>

Optional per-dimension multiplicative weights applied to every point before it reaches the forest’s hot paths (update, score, attribution, bootstrap, delete_by_value). Length must match the forest’s compile-time dimension D.

Intended for per-feature scale normalisation: when different input dimensions have wildly different dynamic ranges (packet-rate in [10², 10⁶], protocol-mix ratios in [0, 1], entropy in [0, 8] bits), a naive random cut weights each dimension by its raw range. Pre-scaling with 1 / stddev[d] recovers a unit-variance input space where every dim pulls its weight. For full z-score normalisation the caller should still mean-centre upstream — feature_scales is a weight, not a full affine transform.

None keeps the classic “forest sees the raw caller point” behaviour. The field is #[serde(default)] so old snapshots deserialise without migration.

Implementations

impl RcfConfig

pub fn validate(&self) -> RcfResult<()>

Validate the configuration against the AWS hyperparameter bounds. The forest’s compile-time dimension D is checked separately via Self::validate_dimension so non-const callers can apply the AWS bounds without instantiating a generic.

Errors

Returns RcfError::InvalidConfig with the offending parameter when any bound is violated.

pub fn validate_feature_scales_dimension(&self, d: usize) -> RcfResult<()>

Validate the declared RcfConfig::feature_scales against a target per-point dimension d. When feature_scales is None, the check is a no-op.

Errors

Returns RcfError::DimensionMismatch when the scales vector length does not equal d.

pub fn validate_dimension(dimension: usize) -> RcfResult<()>

Validate the compile-time dimension D against the AWS feature_dim bounds. Called by ForestBuilder::build so every user-facing entry point gates on the AWS limits.

Errors

Returns RcfError::InvalidConfig when D is outside [MIN_DIMENSION, MAX_DIMENSION].

Trait Implementations

impl Clone for RcfConfig

fn clone(&self) -> RcfConfig

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for RcfConfig

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for RcfConfig

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for RcfConfig

fn eq(&self, other: &RcfConfig) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for RcfConfig

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for RcfConfig