From 8720530d4eff9dd2123ec0f85a65fbf34e34025d Mon Sep 17 00:00:00 2001
From: NunoSempere <nuno.semperelh@protonmail.com>
Date: Sun, 29 Dec 2024 01:04:22 +0100
Subject: [PATCH] fengshui

---
 README.md               |   4 +-
 simple/simple_pretty.go | 135 ++++++++++++++++++++++++++++++++++++++++
 2 files changed, 137 insertions(+), 2 deletions(-)
 create mode 100644 simple/simple_pretty.go

diff --git a/README.md b/README.md
index 64291a9..2e90a02 100644
--- a/README.md
+++ b/README.md
@@ -197,11 +197,11 @@ Done:
 - [x] Add percentages
 - [x] Consider adding an understanding of percentages
 - [x] Improve and rationalize error messages a bit
+- [x] Add, then document mixture distributions
 
 To (possibly) do:
 
-- [ ] Consider implications of sampling strategy for operating variables in this case.
-- [ ] Document mixture distributions
+- [ ] Consider implications of sampling strategy for operating variables.
 - [ ] Fix lognormal multiplication and division by 0 or < 0
 - [ ] With the -f command line option, the program doesn't read from stdin after finishing reading the file
 - [ ] Add functions. Now easier to do with an explicit representation of the stack
diff --git a/simple/simple_pretty.go b/simple/simple_pretty.go
new file mode 100644
index 0000000..2b2feed
--- /dev/null
+++ b/simple/simple_pretty.go
@@ -0,0 +1,135 @@
+package main
+
+import (
+	"errors"
+	"fmt"
+	"git.nunosempere.com/NunoSempere/fermi/sample"
+	"math"
+	"sort"
+	"strconv"
+)
+
+func PrettyPrintInt(n int) {
+	switch {
+	case math.Abs(float64(n)) >= 1_000_000_000_000:
+		fmt.Printf("%.2fT", float64(n)/1_000_000_000_000.0)
+	case math.Abs(float64(n)) >= 1_000_000_000:
+		fmt.Printf("%.2fB", float64(n)/1_000_000_000.0)
+	case math.Abs(float64(n)) >= 1_000_000:
+		fmt.Printf("%.2fM", float64(n)/1_000_000.0)
+	case math.Abs(float64(n)) >= 1_000:
+		fmt.Printf("%.2fK", float64(n)/1_000.0)
+	default:
+		fmt.Printf("%d", n)
+	}
+}
+
+func PrettyPrintFloat(f float64) {
+	switch {
+	case math.Abs(f) >= 1_000_000_000_000:
+		fmt.Printf("%.2fT", f/1_000_000_000_000)
+	case math.Abs(f) >= 1_000_000_000:
+		fmt.Printf("%.2fB", f/1_000_000_000)
+	case math.Abs(f) >= 1_000_000:
+		fmt.Printf("%.2fM", f/1_000_000)
+	case math.Abs(f) >= 1_000:
+		fmt.Printf("%.2fK", f/1_000)
+
+	case math.Abs(f) <= 0.0001:
+		fmt.Printf("%.6f", f)
+	case math.Abs(f) <= 0.001:
+		fmt.Printf("%.5f", f)
+	case math.Abs(f) <= 0.01:
+		fmt.Printf("%.4f", f)
+	case math.Abs(f) <= 0.1:
+		fmt.Printf("%.3f", f)
+	default:
+		fmt.Printf("%.2f", f)
+	}
+
+}
+func PrettyPrint2Floats(low float64, high float64) {
+	PrettyPrintFloat(low)
+	fmt.Printf(" ")
+	PrettyPrintFloat(high)
+}
+
+func multiplyOrPassThroughError(a float64, b float64, err error) (float64, error) {
+	if err != nil {
+		return b, err
+	} else {
+		return a * b, nil
+	}
+}
+
+func ParseFloat(word string) (float64, error) {
+	// l = len(word) // assuming no UTF stuff
+	switch len(word) {
+	case 0:
+		return 0, errors.New("String to be parsed into float must not be the empty string")
+	case 1:
+		return strconv.ParseFloat(word, 64)
+	}
+
+	n := len(word) - 1
+	f, err := strconv.ParseFloat(word[:n], 64)
+	switch word[n] {
+	case '%':
+		return multiplyOrPassThroughError(0.01, f, err)
+	case 'K':
+		return multiplyOrPassThroughError(1_000, f, err)
+	case 'M':
+		return multiplyOrPassThroughError(1_000_000, f, err)
+	case 'B':
+		return multiplyOrPassThroughError(1_000_000_000, f, err)
+	case 'T':
+		return multiplyOrPassThroughError(1_000_000_000_000, f, err)
+	default:
+		return strconv.ParseFloat(word, 64)
+	}
+
+}
+
+/* Printers */
+func PrettyPrintDist(dist Dist) {
+	switch v := dist.(type) {
+	case Lognormal:
+		fmt.Printf("=> ")
+		PrettyPrint2Floats(v.low, v.high)
+		fmt.Println()
+	case Beta:
+		fmt.Printf("=> beta ")
+		PrettyPrint2Floats(v.a, v.b)
+		fmt.Println()
+	case Scalar:
+		fmt.Printf("=> scalar ")
+		w := float64(v)
+		PrettyPrintFloat(w)
+		fmt.Println()
+	case FilledSamples:
+		n := len(v.xs)
+		sorted_xs := make([]float64, n)
+		copy(sorted_xs, v.xs)
+		sort.Slice(sorted_xs, func(i, j int) bool {
+			return sorted_xs[i] < sorted_xs[j]
+		})
+
+		low := sorted_xs[int(math.Round(float64(n)*0.05))]
+		high := sorted_xs[int(math.Round(float64(n)*0.95))]
+		fmt.Printf("=> ")
+		PrettyPrint2Floats(low, high)
+
+		fmt.Printf(" (")
+		PrettyPrintInt(N_SAMPLES)
+		fmt.Printf(" samples)")
+		fmt.Println()
+	default:
+		fmt.Printf("%v\n", v)
+	}
+}
+
+func PrintAndReturnErr(err_msg string) error {
+	fmt.Println(err_msg)
+	fmt.Println("Type \"help\" (without quotes) to see a pseudogrammar and examples")
+	return errors.New(err_msg)
+}