Struct WeightedMedianProcessor 

pub struct WeightedMedianProcessor {
    pub source_weights: HashMap<String, u32>,
    pub minimum_cumulative_weight: u32,
}

Processor that calculates the weighted median of input values.

The WeightedMedianProcessor computes the weighted median of a set of input values, taking into account the relative importance (weight) of each data source. This provides a way to give more influence to more reliable or important sources when determining the central value.

Source Weights

Each source is assigned a weight using the source_weights mapping. Sources with higher weights have more influence on the resulting median value. Sources that are not present in the mapping will cause processing to fail.

Minimum Cumulative Weight

The processor requires the sum of weights from all provided sources to meet or exceed the minimum_cumulative_weight threshold. This ensures that enough reliable data is present to calculate a statistically significant result.

Examples

use std::collections::HashMap;
use bothan_lib::registry::processor::{Processor, weighted_median::WeightedMedianProcessor};
use rust_decimal::Decimal;

// Create weights for different sources
let weights = HashMap::from([
    ("source1".to_string(), 10),
    ("source2".to_string(), 20),
    ("source3".to_string(), 30),
]);

// Create a weighted median processor
let processor = Processor::WeightedMedian(WeightedMedianProcessor {
    source_weights: weights,
    minimum_cumulative_weight: 50,
});

// Process data with different weights
let data = vec![
    ("source1".to_string(), Decimal::new(100, 0)), // Weight: 10
    ("source2".to_string(), Decimal::new(200, 0)), // Weight: 20
    ("source3".to_string(), Decimal::new(300, 0)), // Weight: 30
];

let result = processor.process(data).unwrap();
// The result is biased toward the value from source3 since it has the highest weight

Fields

source_weights: HashMap<String, u32>

Mapping of source identifiers to their respective weights.

Each source is assigned a weight, which determines its influence on the resulting median calculation. Sources with higher weights have more impact on the final result.

minimum_cumulative_weight: u32

The minimum sum of weights required for a valid calculation.

Processing will fail if the sum of weights from all provided sources does not meet this threshold. This ensures sufficient data quality and statistical significance.

Implementations

impl WeightedMedianProcessor

pub fn new( source_weights: HashMap<String, u32>, minimum_cumulative_weight: u32, ) -> Self

Creates a new WeightedMedianProcessor with the specified weights and minimum threshold.

Examples

use std::collections::HashMap;
use bothan_lib::registry::processor::weighted_median::WeightedMedianProcessor;

// Create weights for different sources
let weights = HashMap::from([
    ("binance".to_string(), 30),
    ("coinbase".to_string(), 25),
    ("kraken".to_string(), 20),
    ("kucoin".to_string(), 15),
]);

// Create a processor that requires a minimum cumulative weight of 50
let processor = WeightedMedianProcessor::new(weights, 50);

impl WeightedMedianProcessor

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

Calculates the weighted median of the provided values.

This method computes the weighted median based on the source weights configuration. It first validates that all sources have defined weights and that the cumulative weight meets the minimum threshold.

Errors

Returns a ProcessError if:

• Any source in the input data does not have a defined weight
• The cumulative weight of all provided sources is less than the minimum threshold

Trait Implementations

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

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 WeightedMedianProcessor

fn clone(&self) -> WeightedMedianProcessor

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for WeightedMedianProcessor

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

Formats the value using the given formatter.

impl<__Context> Decode<__Context> for WeightedMedianProcessor

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 WeightedMedianProcessor

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Encode for WeightedMedianProcessor

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

Encode a given type.

impl PartialEq for WeightedMedianProcessor

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

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 WeightedMedianProcessor