fermi/f.go

package main

import (
	"bufio"
	"errors"
	"fmt"
	"git.nunosempere.com/NunoSempere/fermi/sample"
	"math"
	"os"
	"strconv"
	"strings"
)

const NORMAL90CONFIDENCE = 1.6448536269514727
const GENERAL_ERR_MSG = "Valid inputs: 2 || * 2 || / 2 || 2 20 || * 2 20 || / 2 20 || clean || =: var || op var || clean || help || debug || exit"

// Distribution interface
// https://go.dev/tour/methods/9

type Distribution interface {
	Samples() []float64
}

type Lognormal struct {
	low  float64
	high float64
}

func (l Lognormal) Samples() []float64 {
	sampler := func(r sample.Src) float64 { return sample.Sample_to(l.low, l.high, r) }
	return sample.Sample_parallel(sampler, 1_000_000)
}

type Beta struct {
	a float64
	b float64
}

type FilledSamples struct {
	xs []float64
}

func (fs FilledSamples) Samples() []float64 {
	return fs.xs
}

// 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 parseLineErr(err_msg string) (string, Dist, error) {
	fmt.Println(GENERAL_ERR_MSG)
	fmt.Println(err_msg)
	return "", Dist{}, errors.New(err_msg)
}
func parseLine(line string, vars map[string]Dist) (string, Dist, error) {

	words := strings.Split(strings.TrimSpace(line), " ")
	op := ""
	var dist Dist

	switch words[0] {
	case "*":
		op = "*"
		words = words[1:]
	case "/":
		op = "/"
		words = words[1:]
	case "+":
		return parseLineErr("+ operation not implemented yet")
	case "-":
		return parseLineErr("- operation not implemented yet")
	default:
		op = "*" // later, change the below to
	}

	switch len(words) {
	case 0:
		return parseLineErr("Operator must have operand; can't operate on nothing")
	case 1:
		var_word, var_word_exists := vars[words[0]]
		single_float, err1 := strconv.ParseFloat(words[0], 64) // abstract this away to search for K/M/B/T/etc.
		switch {
		case var_word_exists:
			dist = var_word
		case err1 == nil:
			dist = Dist{Type: "Lognormal", Lognormal: Lognormal{low: single_float, high: single_float}, Samples: nil}
		case err1 != nil && !var_word_exists:
			return parseLineErr("Trying to operate on a scalar, but scalar is neither a float nor an assigned variable")
		}
	case 2:
		new_low, err1 := strconv.ParseFloat(words[0], 64)
		new_high, err2 := strconv.ParseFloat(words[1], 64)
		if err1 != nil || err2 != nil {
			return parseLineErr("Trying to operate by a distribution, but distribution is not specified as two floats")
		}
		dist = Dist{Type: "Lognormal", Lognormal: Lognormal{low: new_low, high: new_high}, Samples: nil}
	default:
		return parseLineErr("Other input methods not implemented yet")
	}
	return op, dist, nil

}

// Join distributions
// Multiply lognormals

func multiplyLogDists(l1 Lognormal, l2 Lognormal) Lognormal {
	logmean1 := (math.Log(l1.high) + math.Log(l1.low)) / 2.0
	logstd1 := (math.Log(l1.high) - math.Log(l1.low)) / (2.0 * NORMAL90CONFIDENCE)

	logmean2 := (math.Log(l2.high) + math.Log(l2.low)) / 2.0
	logstd2 := (math.Log(l2.high) - math.Log(l2.low)) / (2.0 * NORMAL90CONFIDENCE)

	logmean_product := logmean1 + logmean2
	logstd_product := math.Sqrt(logstd1*logstd1 + logstd2*logstd2)

	h := logstd_product * NORMAL90CONFIDENCE
	loglow := logmean_product - h
	loghigh := logmean_product + h
	return Lognormal{low: math.Exp(loglow), high: math.Exp(loghigh)}

}

func joinDists(old_dist Dist, new_dist Dist, op string) (Dist, error) {
	switch {
	case old_dist.Type == "Lognormal" && new_dist.Type == "Lognormal" && op == "*":
		return Dist{Type: "Lognormal", Lognormal: multiplyLogDists(old_dist.Lognormal, new_dist.Lognormal), Samples: nil}, nil
	case old_dist.Type == "Lognormal" && new_dist.Type == "Lognormal" && op == "/":
		tmp_dist := Lognormal{low: 1.0 / new_dist.Lognormal.high, high: 1.0 / new_dist.Lognormal.low}
		return Dist{Type: "Lognormal", Lognormal: multiplyLogDists(old_dist.Lognormal, tmp_dist), Samples: nil}, nil
	default:
		fmt.Printf("For now, can't do anything besides multiplying lognormals\n")
	}
	return old_dist, errors.New("Can't combine distributions in this way")
}

/* Pretty print distributions */
func prettyPrintLognormal(low float64, high float64) {
	// fmt.Printf("=> %.1f %.1f\n", low, high)
	fmt.Printf("=> ")
	switch {
	case math.Abs(low) >= 1_000_000_000_000:
		fmt.Printf("%.1fT", low/1_000_000_000_000)
	case math.Abs(low) >= 1_000_000_000:
		fmt.Printf("%.1fB", low/1_000_000_000)
	case math.Abs(low) >= 1_000_000:
		fmt.Printf("%.1fM", low/1_000_000)
	case math.Abs(low) >= 1_000:
		fmt.Printf("%.1fK", low/1_000)
	case math.Abs(low) >= 1_000:
		fmt.Printf("%.1fK", low/1_000)
	default:
		fmt.Printf("%.1f", low)
	}
	fmt.Printf(" ")
	switch {
	case math.Abs(high) >= 1_000_000_000_000:
		fmt.Printf("%.1fT", high/1_000_000_000_000)
	case math.Abs(high) >= 1_000_000_000:
		fmt.Printf("%.1fB", high/1_000_000_000)
	case math.Abs(high) >= 1_000_000:
		fmt.Printf("%.1fM", high/1_000_000)
	case math.Abs(high) >= 1_000:
		fmt.Printf("%.1fK", high/1_000)
	case math.Abs(high) >= 1_000:
		fmt.Printf("%.1fK", high/1_000)
	default:
		fmt.Printf("%.1f", high)
	}
	fmt.Printf("\n")
	// fmt.Printf("=> %.1f %.1f\n", low, high)
}

func prettyPrintDist(dist Dist) {
	if dist.Type == "Lognormal" {
		prettyPrintLognormal(dist.Lognormal.low, dist.Lognormal.high)
	} else {
		fmt.Printf("%v", dist)
	}
}

/* Main event loop */
func main() {

	sample_0 := func(r sample.Src) float64 { return 0 }
	x := sample.Sample_parallel(sample_0, 10)
	fmt.Printf("%v\n", x)

	reader := bufio.NewReader(os.Stdin)
	init_dist := Dist{Type: "Lognormal", Lognormal: Lognormal{low: 1, high: 1}, Samples: nil} // Could also just be a scalar
	old_dist := init_dist
	vars := make(map[string]Dist)
	// Could eventually be a more complex struct with:
	// { Dist, VariableMaps, ConfigParams } or smth
EventForLoop:
	for {
		input, _ := reader.ReadString('\n')
		if strings.TrimSpace(input) == "" {
			continue EventForLoop
		}

		{
			words := strings.Split(strings.TrimSpace(input), " ")
			switch {
			case words[0] == "exit" || words[0] == "e":
				break EventForLoop
			case words[0] == "help" || words[0] == "h":
				fmt.Println(GENERAL_ERR_MSG)
				continue EventForLoop
			case words[0] == "debug" || words[0] == "d":
				fmt.Printf("Old dist: %v\n", old_dist)
				fmt.Printf("Vars: %v\n", vars)
				continue EventForLoop
			case words[0] == "=:" && len(words) == 2:
				vars[words[1]] = old_dist
				fmt.Printf("%s ", words[1])
				prettyPrintDist(old_dist)
				continue EventForLoop
			case words[0] == "." || words[0] == "clean" || words[0] == "c":
				old_dist = init_dist
				fmt.Println()
				continue EventForLoop
			case words[0] == "=." && len(words) == 2:
				vars[words[1]] = old_dist
				fmt.Printf("%s ", words[1])
				prettyPrintDist(old_dist)
				old_dist = init_dist
				fmt.Println()
				continue EventForLoop
				// Other possible cases:
				// Save to file
				// Sample n samples
				// Save stack to a variable?
				// clean stack
				// Define a function? No, too much of a nerdsnipea
			}
		}

		op, new_dist, err := parseLine(input, vars)
		if err != nil {
			continue EventForLoop
		}

		joint_dist, err := joinDists(old_dist, new_dist, op)
		if err != nil {
			continue EventForLoop
		}
		old_dist = joint_dist
		prettyPrintDist(old_dist)
	}
}