fengshui

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

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)
+}