Struct MedianProcessor 

pub struct MedianProcessor {
    pub min_source_count: usize,
}

Processor that calculates the median of input values.

The MedianProcessor computes the median of a set of input values, requiring a minimum number of data sources to be present. This provides a robust measure of central tendency that is resistant to outliers in the data.

Minimum Source Count

The processor requires at least min_source_count data points to calculate a median. If fewer data points are provided, processing will fail with an error.

Median Calculation

• For odd number of values, returns the middle value after sorting
• For even number of values, returns the average of the two middle values

Examples

use bothan_lib::registry::processor::{Processor, median::MedianProcessor};
use rust_decimal::Decimal;

// Create a median processor that requires at least 3 sources
let processor = Processor::Median(MedianProcessor { min_source_count: 3 });

// Process some data with 5 values
let data = vec![
    ("source1".to_string(), Decimal::new(100, 0)),
    ("source2".to_string(), Decimal::new(200, 0)),
    ("source3".to_string(), Decimal::new(300, 0)),
    ("source4".to_string(), Decimal::new(400, 0)),
    ("source5".to_string(), Decimal::new(500, 0)),
];

let result = processor.process(data).unwrap();
assert_eq!(result, Decimal::new(300, 0)); // Median is 300

Fields

min_source_count: usize

The minimum number of sources required to calculate the median.

If fewer than this number of data points are provided, the processing will fail with an error.

Implementations

impl MedianProcessor

pub fn new(min_source_count: usize) -> Self

Creates a new MedianProcessor with the specified minimum source count.

The minimum source count determines how many data points are required at minimum to calculate a valid median. This helps ensure the result has sufficient statistical significance.

Examples

use bothan_lib::registry::processor::median::MedianProcessor;

// Create a processor that requires at least 3 sources
let processor = MedianProcessor::new(3);

pub fn process(&self, data: Vec<Decimal>) -> Result<Decimal, ProcessError>

Calculates the median of the provided decimal values.

This method computes the median of the input values, failing if there are fewer data points than the required minimum.

Errors

Returns a ProcessError if there are fewer than min_source_count data points.

Trait Implementations

impl<'__de, __Context> BorrowDecode<'__de, __Context> for MedianProcessor

fn borrow_decode<__D: BorrowDecoder<'__de, Context = __Context>>( decoder: &mut __D, ) -> Result<Self, DecodeError>

Attempt to decode this type with the given BorrowDecode.

impl Clone for MedianProcessor

fn clone(&self) -> MedianProcessor

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for MedianProcessor

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

Formats the value using the given formatter.

impl<__Context> Decode<__Context> for MedianProcessor

fn decode<__D: Decoder<Context = __Context>>( decoder: &mut __D, ) -> Result<Self, DecodeError>

Attempt to decode this type with the given Decode.

impl<'de> Deserialize<'de> for MedianProcessor

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Encode for MedianProcessor

fn encode<__E: Encoder>(&self, encoder: &mut __E) -> Result<(), EncodeError>

Encode a given type.

impl PartialEq for MedianProcessor

fn eq(&self, other: &MedianProcessor) -> 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 MedianProcessor

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 MedianProcessor