use crate::errors::stats_error::StatsError;
use crate::types::entropy_config::EntropyConfig;
use crate::types::log_base::LogBase;
use crate::types::normalisation::Normalisation;
use crate::types::pairwise_sum::pairwise_sum;
use crate::types::zero_policy::ZeroPolicy;
use deep_causality_algebra::RealField;
use deep_causality_num::FromPrimitive;
pub fn entropy<T>(p: &[T], config: &EntropyConfig<T>) -> Result<T, StatsError>
where
T: RealField + FromPrimitive,
{
let (total, rescale, scale) = prepare(p, config)?;
if total {
return Ok(T::zero());
}
Ok(surprisal_sum(p, config, rescale, scale))
}
fn prepare<T>(p: &[T], config: &EntropyConfig<T>) -> Result<(bool, T, T), StatsError>
where
T: RealField + FromPrimitive,
{
if p.is_empty() {
return Err(StatsError::EmptyInput(
"the entropy of no outcomes is undefined",
));
}
if p.iter().any(|&x| !x.is_finite()) {
return Err(StatsError::NonFiniteInput(
"a non-finite entry has no surprisal, and no distribution contains one",
));
}
if p.iter().any(|&x| x < T::zero()) {
return Err(StatsError::NegativeProbability(
"a negative entry is not a probability, and no zero policy interprets one",
));
}
match config.normalisation {
Normalisation::None => Ok((false, T::one(), T::one())),
Normalisation::BySum { floor } => {
let sum = pairwise_sum(p, |x| x);
if sum <= floor {
return Ok((true, T::one(), T::one()));
}
if sum.is_finite() {
return Ok((false, T::one(), sum));
}
let largest = p.iter().fold(T::zero(), |m, &x| if x > m { x } else { m });
let scaled = pairwise_sum(p, |x| x / largest);
Ok((false, largest, scaled))
}
}
}
fn surprisal_sum<T>(p: &[T], config: &EntropyConfig<T>, rescale: T, scale: T) -> T
where
T: RealField + FromPrimitive,
{
let ln_base = match config.base {
LogBase::Bits => (T::one() + T::one()).ln(),
LogBase::Nats => T::one(),
};
let acc = pairwise_sum(p, |raw| {
let q = raw / rescale / scale;
if q <= T::zero() {
return T::zero();
}
let keep = match config.zero_policy {
ZeroPolicy::SkipZero => true,
ZeroPolicy::SkipBelow(threshold) => q > threshold,
};
if keep { -(q * q.ln()) } else { T::zero() }
});
acc / ln_base
}
pub fn conditional_entropy<T>(
joint: &[T],
conditioning: &[T],
config: &EntropyConfig<T>,
) -> Result<T, StatsError>
where
T: RealField + FromPrimitive,
{
let h_joint = entropy(joint, config)?;
let h_conditioning = entropy(conditioning, config)?;
Ok(h_joint - h_conditioning)
}