commit de72432c53db09dc4e3f174d15afbf764967e087
parent f5e7148148bf3f4bec67bd856060ce7b07d28439
Author: NunoSempere <nuno.semperelh@protonmail.com>
Date: Sun, 9 Jun 2024 13:18:09 +0200
continue with new parser, steps now seem way more clear
Diffstat:
| M | f2.go | | | 76 | +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++----- |
1 file changed, 71 insertions(+), 5 deletions(-)
diff --git a/f2.go b/f2.go
@@ -2,13 +2,17 @@ package main
import (
"bufio"
+ "errors"
"fmt"
+
// "math"
"os"
// "strconv"
"strings"
)
+const NORMAL90CONFIDENCE = 1.6448536269514727
+
// Actually, I should look up how do do a) enums in go, b) union types
type Lognormal struct {
low float64
@@ -21,21 +25,83 @@ type Dist struct {
Samples []float64
}
+// Parse line into Distribution,
func parseLine(line string) (string, Dist, error) {
words := strings.Split(strings.TrimSpace(line), " ")
+ op = ""
+ var dist Dist
+
+ switch words[0] {
+ case "*":
+ op = "*"
+ case "/":
+ op = "/"
+ case "+":
+ return "", Dist{}, error.New("+ operation not implemented yet")
+ case "-":
+ return "", Dist{}, error.New("- operation not implemented yet")
+ default:
+ return "", Dist{}, error.New("operation not recognized")
+ }
+
+ switch len(words) {
+ case 1:
+ return "", Dist{}, error.New("Can't operate on nothing")
+ case 2:
+ single_float, err1 := strconv.ParseFloat(words[1], 64)
+ if err1 != nil {
+ fmt.Println("Trying to operate on a scalar, but scalar is not a float")
+ fmt.Println(error_msg_cont)
+ continue EventForLoop
+ }
+ new_low = single_float
+ new_high = single_float
- switch {
- case len(words) == 2 && words[0] == "*":
- fmt.Printf("Hello world")
}
- return "Lognormal", Dist{}, nil
+
+}
+
+// Join distributions
+// Multiply lognormals
+
+func logBoundsToLogParams(low float64, high float64) (float64, float64) {
+ loglow := math.Log(low)
+ loghigh := math.Log(high)
+ logmean := (loghigh + loglow) / 2.0
+ logstd := (loghigh - loglow) / (2.0 * NORMAL90CONFIDENCE)
+ return logmean, logstd
+}
+func logParamsToLogBounds(logmean float64, logstd float64) (float64, float64) {
+ h := logstd * NORMAL90CONFIDENCE
+ loglow := logmean - h
+ loghigh := logmean + h
+ return math.Exp(loglow), math.Exp(loghigh)
+}
+func multiplyLogParams(logmean1 float64, logstd1 float64, logmean2 float64, logstd2 float64) (float64, float64) {
+ return logmean1 + logmean2, math.Sqrt(logstd1*logstd1 + logstd2*logstd2)
+}
+func multiplyLogBounds(old_low, old_high, new_low, new_high float64) (float64, float64) {
+ logmean_old, logstd_old := logBoundsToLogParams(old_low, old_high)
+ logmean_new, logstd_new := logBoundsToLogParams(new_low, new_high)
+
+ logmean_product, logstd_product := multiplyLogParams(logmean_old, logstd_old, logmean_new, logstd_new)
+
+ return logParamsToLogBounds(logmean_product, logstd_product)
}
func joinDists(old_dist Dist, new_dist Dist, op string) (Dist, error) {
- return old_dist, nil
+ switch {
+ case old_dist.Type == "Lognormal" && new_dist.Type == "Lognormal" && op == "*":
+ low, high := multiplyLogBounds(old_dist.Lognormal.low, old_dist.Lognormal.high, new_dist.Lognormal.low, new_dist.Lognormal.high)
+ return Dist{Type: "Lognormal", Lognormal: Lognormal{low: low, high: high}, Samples: nil}
+ default:
+ fmt.Printf("For now, can't do anything besides multiplying lognormals")
+ }
+ return old_dist, errors.New("Error blah blah")
}
+/* Main event loop */
func main() {
reader := bufio.NewReader(os.Stdin)
old_dist := Dist{Type: "Lognormal", Lognormal: Lognormal{low: 1, high: 1}, Samples: nil} // Could also just be a scalar
