136 lines
3.1 KiB
Go
136 lines
3.1 KiB
Go
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)
|
|
}
|