Number: averages

Signed-off-by: Nathaniel Clark <Nathaniel.Clark@misrule.us>

Author: utopiabound

src/fixtures/help.html

@@ -117,7 +117,10 @@ <h1>RPN-rs is a graphical reverse polish notation (RPN) calculator</h1>
       <tr><td>expand</td><td>1</td><td colspan=2>Push all the values from tuple onto the stack</td></tr>
 
       <tr><th colspan=4>Statistical Operations (meaningful on tuples and matrices)</th></tr>
-      <tr><td>avg | mean</td><td>1</td><td>Find the average value</td><td><i>avg(x)</i></td></tr>
+      <tr><td>avg | mean | amean | AM</td><td>1</td><td>Find the average value (<a href="https://en.wikipedia.org/wiki/Arithmetic_mean">Arithmetic mean</a>)</td><td><i>avg(x)</i></td></tr>
+      <tr><td>gmean | GM</td><td>1</td><td>Find the <a href="https://en.wikipedia.org/wiki/Geometic_mean">Geometric mean</a></td><td><i>GM(x)</i></td></tr>
+      <tr><td>hmean | HM </td><td>1</td><td>Find the <a href="https://en.wikipedia.org/wiki/Harmonic_mean">Harmonic mean</a></td><td><i>HM(x)</i></td></tr>
+      <tr><td>gmdn</td><td>1</td><td>Conduct one iteration of the <a href="https://xkcd.com/2435/">Geothmetic meandian</a> function</td><td><i>GMDN(x)</i></td></tr>
       <tr><td>median</td><td>1</td><td>Find the median value</td><td><i>median(x)</i></td></tr>
       <tr><td>(sd)ev | sigma</td><td>1</td><td>Find the <a href="https://en.wikipedia.org/wiki/Standard_deviation">standard deviation</a></td><td><i>sigma(x)</i></td></tr>
       <tr><td>sum</td><td>1</td><td colspan=2>Add all values in element togther and return sum</td></tr>

src/main.rs

@@ -234,8 +234,11 @@ fn main() {
                     "unpush" => stacks[0].try_unary_v(|a| a.try_unpush()),
                     "pop" => stacks[0].try_unary_v(|a| a.try_pull()),
                     // Tuple / Stats Operations
-                    "avg" | "mean" => stacks[0].unary(|a| a.mean()),
-                    "median" => stacks[0].unary(|a| a.median()),
+                    "avg" | "mean" | "amean" | "AM" => stacks[0].unary(|a| a.mean().into()),
+                    "gmean" | "GM" => stacks[0].unary(|a| a.geometric_mean().into()),
+                    "hmean" | "HM" => stacks[0].unary(|a| a.harmonic_mean().into()),
+                    "median" => stacks[0].unary(|a| a.median().into()),
+                    "gmdn" => stacks[0].unary(|a| a.gmdn()),
                     "sort" => stacks[0].unary(|a| a.sort()),
                     "sum" => stacks[0].unary(|a| a.sum()),
                     "prod" | "product" => stacks[0].unary(|a| a.product()),

src/numbers.rs

@@ -1369,34 +1369,96 @@ impl Value {
     }
 
     // Stats Functions
-    pub(crate) fn mean(self) -> Self {
+    pub(crate) fn mean(self) -> Scalar {
         match self {
-            Value::Scalar(s) => Value::Scalar(s),
+            Value::Scalar(s) => s,
             Value::Tuple(t) => {
                 let len = t.len().into();
                 let v: Scalar = t.into_iter().sum();
-                Value::Scalar(v / len)
+                v / len
             }
             Value::Matrix(m) => {
                 let len: Scalar = Scalar::from(m.rows()) * m.cols().into();
                 let sum: Scalar = m.into_iter().sum();
-                Value::Scalar(sum / len)
+                sum / len
             }
         }
     }
 
-    pub(crate) fn median(self) -> Self {
+    /// Geometric Mean
+    /// n-th root of the product of all the values
+    pub(crate) fn geometric_mean(self) -> Scalar {
         match self {
-            Value::Scalar(s) => Value::Scalar(s),
-            Value::Tuple(t) => Value::Scalar(median(t.into_iter().collect())),
+            Value::Scalar(s) => s,
+            Value::Tuple(t) => {
+                let len = t.len().into();
+                let v: Scalar = t.into_iter().map(|x| x.ln()).sum();
+                (v / len).exp()
+            }
+            Value::Matrix(m) => {
+                let len: Scalar = Scalar::from(m.rows()) * m.cols().into();
+                let sum: Scalar = m.into_iter().map(|x| x.ln()).sum();
+                (sum / len).exp()
+            }
+        }
+    }
+
+    /// Harmonic Mean
+    pub(crate) fn harmonic_mean(self) -> Scalar {
+        match self {
+            Value::Scalar(s) => s,
+            Value::Tuple(t) => {
+                let len: Scalar = t.len().into();
+                let v: Scalar = t.into_iter().map(|x| x.inv()).sum();
+                len / v
+            }
+            Value::Matrix(m) => {
+                let len: Scalar = Scalar::from(m.rows()) * m.cols().into();
+                let sum: Scalar = m.into_iter().map(|x| x.inv()).sum();
+                len / sum
+            }
+        }
+    }
+
+    pub(crate) fn median(self) -> Scalar {
+        match self {
+            Value::Scalar(s) => s,
+            Value::Tuple(t) => median(t.into_iter().collect()),
             Value::Matrix(m) => {
                 let list = m.into_iter().collect::<Vec<_>>();
-                let val = median(list);
-                Value::Scalar(val)
+                median(list)
             }
         }
     }
 
+    /// Geothmetic Meandian (XKCD #2435)
+    ///
+    /// F(x0, x1, ... xN) -> (Arithmatic Mean, Geometric Mean, Median)
+    /// gmdn(...) -> F(F(F(F(...))))) until it converges
+    ///
+    /// This funcition computes a single iteration
+    pub(crate) fn gmdn(self) -> Self {
+        match self {
+            Value::Scalar(s) => Value::Scalar(s),
+            Value::Tuple(_) => Value::Tuple(
+                [
+                    self.clone().mean(),
+                    self.clone().geometric_mean(),
+                    self.median(),
+                ]
+                .into(),
+            ),
+            Value::Matrix(_) => Value::Tuple(
+                [
+                    self.clone().mean(),
+                    self.clone().geometric_mean(),
+                    self.median(),
+                ]
+                .into(),
+            ),
+        }
+    }
+
     pub(crate) fn sort(self) -> Self {
         match self {
             Value::Scalar(s) => Value::Scalar(s),