128 lines
3.2 KiB
Go
128 lines
3.2 KiB
Go
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
|
|
high float64
|
|
}
|
|
|
|
type Dist struct {
|
|
Type string
|
|
Lognormal Lognormal
|
|
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
|
|
|
|
}
|
|
|
|
}
|
|
|
|
// 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) {
|
|
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
|
|
fmt.Printf("Hello world")
|
|
|
|
EventForLoop:
|
|
for {
|
|
input, _ := reader.ReadString('\n')
|
|
if strings.TrimSpace(input) == "" {
|
|
continue EventForLoop
|
|
}
|
|
|
|
op, new_dist, err := parseLine(input)
|
|
if err != nil {
|
|
|
|
}
|
|
joint_dist, err := joinDists(old_dist, new_dist, op)
|
|
if err != nil {
|
|
|
|
}
|
|
old_dist = joint_dist
|
|
}
|
|
}
|