Allow obtaining the mean of a distribution

core/src/ast.rs

@@ -696,6 +696,7 @@ pub(crate) fn resolve_identifier<I: Interrupt>(
 		"true" => Value::Bool(true),
 		"false" => Value::Bool(false),
 		"sample" | "roll" => Value::BuiltInFunction(BuiltInFunction::Sample),
+		"mean" | "average" => Value::BuiltInFunction(BuiltInFunction::Mean),
 		"sqrt" => evaluate_to_value("x: x^(1/2)", scope, attrs, context, int)?,
 		"cbrt" => evaluate_to_value("x: x^(1/3)", scope, attrs, context, int)?,
 		"real" | "re" | "Re" => Value::BuiltInFunction(BuiltInFunction::Real),

core/src/error.rs

@@ -24,6 +24,7 @@
 	},
 	NegativeNumbersNotAllowed,
 	ProbabilityDistributionsNotAllowed,
+	EmptyDistribution,
 	FractionToInteger,
 	ModuloByZero,
 	RandomNumbersNotAvailable,
@@ -173,6 +174,7 @@
 					"probability distributions are not allowed (consider using `sample`)"
 				)
 			}
+			Self::EmptyDistribution => write!(f, "there must be at least one part in a dist"),
 			Self::ParseDateError(s) => write!(f, "failed to convert '{s}' to a date"),
 			Self::ExpectedAString => write!(f, "expected a string"),
 			Self::UnableToInvertFunction(name) => write!(f, "unable to invert function {name}"),

core/src/num/dist.rs

@@ -96,7 +96,24 @@
 			}
 			res = Some(Self::from(k));
 		}
-		Ok(res.expect("there must be at least one part in a dist"))
+		res.ok_or(FendError::EmptyDistribution)
+	}
+
+	pub(crate) fn mean<I: Interrupt>(self, int: &I) -> FResult<Self> {
+		if self.parts.is_empty() {
+			return Err(FendError::EmptyDistribution);
+		} else if self.parts.len() == 1 {
+			return Ok(self);
+		}
+
+		let mut result = Exact::new(Complex::from(0), true);
+		for (k, v) in self.parts {
+			result = Exact::new(k, true)
+				.mul(&Exact::new(Complex::from(Real::from(v)), true), int)?
+				.add(result, int)?;
+		}
+
+		Ok(Self::from(result.value))
 	}
 
 	#[allow(

core/src/num/unit.rs

@@ -537,6 +537,13 @@ impl Value {
 		})
 	}
 
+	pub(crate) fn mean<I: Interrupt>(self, int: &I) -> FResult<Self> {
+		Ok(Self {
+			value: self.value.mean(int)?,
+			..self
+		})
+	}
+
 	fn convert_angle_to_rad<I: Interrupt>(
 		self,
 		scope: Option<Arc<Scope>>,

core/src/value.rs

@@ -349,6 +349,7 @@ impl Value {
 				return Ok(Self::Base(Base::from_plain_base(n)?));
 			}
 			BuiltInFunction::Sample => arg.expect_num()?.sample(context, int)?,
+			BuiltInFunction::Mean => arg.expect_num()?.mean(int)?,
 			BuiltInFunction::Not => return Ok(Self::Bool(!arg.as_bool()?)),
 			BuiltInFunction::Conjugate => arg.expect_num()?.conjugate()?,
 			BuiltInFunction::Real => arg.expect_num()?.real()?,

core/src/value/built_in_function.rs

@@ -31,6 +31,7 @@ pub(crate) enum BuiltInFunction {
 	Log10,
 	Base,
 	Sample,
+	Mean,
 	Not,
 	Conjugate,
 	Real,
@@ -96,6 +97,7 @@ impl BuiltInFunction {
 			Self::Log10 => "log10",
 			Self::Base => "base",
 			Self::Sample => "sample",
+			Self::Mean => "mean",
 			Self::Not => "not",
 			Self::Conjugate => "conjugate",
 			Self::Real => "real",

core/tests/integration_tests.rs

@@ -5936,3 +5936,18 @@ fn test_roman() {
 	test_eval_simple("1452 to roman", "MCDLII");
 	test_eval_simple("20002 to roman", "MMMMMMMMMMMMMMMMMMMMII");
 }
+
+#[test]
+fn test_mean() {
+	test_eval("mean d1", "1");
+	test_eval("mean d2", "1.5");
+	test_eval("mean d500", "250.5");
+
+	test_eval("mean (d1 + d1)", "2");
+	test_eval("mean (d2 + d500)", "252");
+
+	test_eval("mean (d6 / d2)", "2.625");
+	test_eval("mean (d10 / d2)", "4.125");
+
+	test_eval("average d500", "250.5");
+}