bel/ana-ledger
1
0
Fork 0
Code Actions Packages Projects Releases Activity

mv /ana, /ledger to /src/

Browse Source
This commit is contained in:
bel
2023-10-28 09:29:39 -06:00
parent ec6d868ff7
commit ea13bf7e4a
35 changed files with 12 additions and 11 deletions
Download Patch File Download Diff File Expand all files Collapse all files

42
src/ana/legacy_bpi.go Normal file
View File

@@ -0,0 +1,42 @@
package ana
import (
"maps"
"regexp"
"time"
"gogs.inhome.blapointe.com/ana-ledger/src/ledger"
)
func BPIsWithFixedGrowthPrediction(bpis ledger.BPIs, window time.Duration, pattern string, apy float64) (ledger.BPIs, error) {
last := map[ledger.Currency]struct {
t string
v float64
}{}
for currency, bpi := range bpis {
for date, value := range bpi {
if date > last[currency].t {
was := last[currency]
was.t = date
was.v = value
last[currency] = was
}
}
}
result := make(ledger.BPIs)
p := regexp.MustCompile(pattern)
for currency, v := range bpis {
result[currency] = maps.Clone(v)
if p.MatchString(string(currency)) {
for _, predictionTime := range predictionTimes(window) {
k2 := predictionTime.Format("2006-01")
was := last[currency]
was.v *= 1.0 + (apy / 12.0)
result[currency][k2] = was.v
last[currency] = was
}
}
}
return result, nil
}

35
src/ana/legacy_bpi_test.go Normal file
View File

@@ -0,0 +1,35 @@
package ana
import (
"slices"
"testing"
"time"
"gogs.inhome.blapointe.com/ana-ledger/src/ledger"
)
func TestBPIPrediction(t *testing.T) {
t.Run("fixed growth", func(t *testing.T) {
bpis := ledger.BPIs{
ledger.USD: ledger.BPI{
"2001-01": -1000,
"2001-02": 100,
},
}
got, err := BPIsWithFixedGrowthPrediction(bpis, time.Hour*24*365, string(ledger.USD), 0.06)
if err != nil {
t.Fatal(err)
}
dates := []string{}
for d := range got[ledger.USD] {
dates = append(dates, d)
}
slices.Sort(dates)
for _, d := range dates {
t.Logf("%s | %s %.2f", ledger.USD, d, got[ledger.USD][d])
}
})
}

45
src/ana/prediction.go Normal file
View File

@@ -0,0 +1,45 @@
package ana
import (
"maps"
"time"
"gogs.inhome.blapointe.com/ana-ledger/src/ledger"
)
type Prediction []Predictor
func NewPrediction(predictor ...Predictor) Prediction {
return Prediction(predictor)
}
func (prediction Prediction) Predict(register ledger.Register, window time.Duration) ledger.Register {
return prediction.predict(register.Latest(), time.Now(), predictionTimes(window))
}
func (prediction Prediction) predict(latest ledger.Balances, from time.Time, these []time.Time) ledger.Register {
latestT := from
result := make(ledger.Register)
for i := range these {
k := these[i].Format("2006-01")
result[k] = make(ledger.Balances)
for k2, v2 := range latest {
result[k][k2] = maps.Clone(v2)
}
elapsed := these[i].Sub(latestT)
result[k] = prediction.predictOne(result[k], elapsed)
latest = result[k]
latestT = these[i]
}
return result
}
func (prediction Prediction) predictOne(balances ledger.Balances, elapsed time.Duration) ledger.Balances {
for i := range prediction {
next := prediction[i](balances, elapsed)
balances = next
}
return balances
}

121
src/ana/prediction_test.go Normal file
View File

@@ -0,0 +1,121 @@
package ana
import (
"maps"
"testing"
"time"
"gogs.inhome.blapointe.com/ana-ledger/src/ledger"
)
func TestPredictionPredict(t *testing.T) {
inc := func(b ledger.Balances, _ time.Duration) ledger.Balances {
result := make(ledger.Balances)
for k, v := range b {
result[k] = maps.Clone(v)
for k2, v2 := range result[k] {
result[k][k2] = v2 + 1
}
}
return result
}
double := func(b ledger.Balances, _ time.Duration) ledger.Balances {
result := make(ledger.Balances)
for k, v := range b {
result[k] = maps.Clone(v)
for k2, v2 := range result[k] {
result[k][k2] = v2 * 2
}
}
return result
}
from := time.Now()
month := time.Hour * 24 * 365 / 12
these := []time.Time{time.Now().Add(time.Hour * 24 * 365 / 12)}
theseK := these[0].Format("2006-01")
thisMonth := time.Now().Add(-1 * time.Duration(time.Now().Day()) * time.Hour * 24)
monthsAgo1 := thisMonth.Add(-1 * month).Format("2006-01")
monthsAgo2 := thisMonth.Add(-2 * month).Format("2006-01")
_, _ = inc, double
cases := map[string]struct {
prediction Prediction
given ledger.Balances
want ledger.Register
}{
"empty": {
want: ledger.Register{theseK: {}},
},
"double": {
prediction: Prediction{double},
given: ledger.Balances{"X": ledger.Balance{"X": 2}},
want: ledger.Register{theseK: ledger.Balances{"X": ledger.Balance{"X": 4}}},
},
"inc": {
prediction: Prediction{inc},
given: ledger.Balances{"X": ledger.Balance{"X": 2}},
want: ledger.Register{theseK: ledger.Balances{"X": ledger.Balance{"X": 3}}},
},
"inc, double": {
prediction: Prediction{inc, double},
given: ledger.Balances{"X": ledger.Balance{"X": 5}},
want: ledger.Register{theseK: ledger.Balances{"X": ledger.Balance{"X": 12}}},
},
"double, inc": {
prediction: Prediction{double, inc},
given: ledger.Balances{"X": ledger.Balance{"X": 5}},
want: ledger.Register{theseK: ledger.Balances{"X": ledger.Balance{"X": 11}}},
},
"contribution": {
prediction: Prediction{
NewAutoContributionPredictor(ledger.Register{
"2001-01": ledger.Balances{"X": ledger.Balance{"X": 100}}, // too old
"2001-02": ledger.Balances{"X": ledger.Balance{"X": 10000}}, // too old
monthsAgo2: ledger.Balances{"X": ledger.Balance{"X": 100}},
monthsAgo1: ledger.Balances{"X": ledger.Balance{"X": 700}}, // +600 once in 6 months
}),
},
given: ledger.Balances{"X": ledger.Balance{"X": 5}},
want: ledger.Register{theseK: ledger.Balances{"X": ledger.Balance{"X": 5}}}, // too few contributions
},
"interest": {
prediction: Prediction{
NewInterestPredictor("X", "X", 12),
},
given: ledger.Balances{"X": ledger.Balance{"X": 5}},
want: ledger.Register{theseK: ledger.Balances{"X": ledger.Balance{"X": 10}}},
},
"interest, contribution": {
prediction: Prediction{
NewInterestPredictor("X", "X", 12),
NewAutoContributionPredictor(ledger.Register{
monthsAgo2: ledger.Balances{"X": ledger.Balance{"X": 100}},
monthsAgo1: ledger.Balances{"X": ledger.Balance{"X": 700}},
}),
},
given: ledger.Balances{"X": ledger.Balance{"X": 5}},
want: ledger.Register{theseK: ledger.Balances{"X": ledger.Balance{"X": 10}}}, // too few contributions
},
"contribution, interest": {
prediction: Prediction{
NewAutoContributionPredictor(ledger.Register{
monthsAgo2: ledger.Balances{"X": ledger.Balance{"X": 100}},
monthsAgo1: ledger.Balances{"X": ledger.Balance{"X": 700}},
}),
NewInterestPredictor("X", "X", 12),
},
given: ledger.Balances{"X": ledger.Balance{"X": 5}},
want: ledger.Register{theseK: ledger.Balances{"X": ledger.Balance{"X": 10}}}, // too few contributions
},
}
for name, d := range cases {
c := d
t.Run(name, func(t *testing.T) {
got := c.prediction.predict(c.given, from, these)
if got.Debug() != c.want.Debug() {
t.Errorf("want\n\t%+v, got\n\t%+v", c.want.Debug(), got.Debug())
}
})
}
}

159
src/ana/predictor.go Normal file
View File

@@ -0,0 +1,159 @@
package ana
import (
"maps"
"math"
"regexp"
"slices"
"time"
"gogs.inhome.blapointe.com/ana-ledger/src/ledger"
)
const (
month = time.Hour * 24 * 365 / 12
)
type Predictor func(ledger.Balances, time.Duration) ledger.Balances
func NewInterestPredictor(namePattern string, currencyPattern string, apy float64) Predictor {
nameMatcher := regexp.MustCompile(namePattern)
currencyMatcher := regexp.MustCompile(currencyPattern)
return func(given ledger.Balances, delta time.Duration) ledger.Balances {
result := maps.Clone(given)
for k, v := range result {
result[k] = maps.Clone(v)
}
monthsPassed := float64(delta) / float64(month)
scalar := math.Pow(1.0+apy/12.0, monthsPassed)
for name := range result {
if !nameMatcher.MatchString(name) {
continue
}
for currency := range result[name] {
if !currencyMatcher.MatchString(string(currency)) {
continue
}
result[name][currency] *= scalar
}
}
return result
}
}
func NewAutoContributionPredictor(reg ledger.Register) Predictor {
monthlyRate := getMonthlyAutoContributionRates(reg)
return NewContributionPredictor(monthlyRate)
}
func NewContributionPredictor(monthlyRate ledger.Balances) Predictor {
return func(given ledger.Balances, delta time.Duration) ledger.Balances {
months := float64(delta) / float64(month)
result := make(ledger.Balances)
for k, v := range given {
result[k] = maps.Clone(v)
}
for name := range monthlyRate {
if _, ok := result[name]; !ok {
result[name] = make(ledger.Balance)
}
for currency := range monthlyRate[name] {
result[name][currency] += monthlyRate[name][currency] * months
}
}
return result
}
}
func getMonthlyAutoContributionRates(reg ledger.Register) map[string]ledger.Balance {
window := 6 * month
window = 12 * month
contributions := getRecentContributions(reg, window)
result := make(map[string]ledger.Balance)
for name := range contributions {
result[name] = getMonthlyAutoContributionRate(contributions[name], window)
}
return result
}
func getMonthlyAutoContributionRate(contributions []ledger.Balance, window time.Duration) ledger.Balance {
currencies := map[ledger.Currency]int{}
for _, balance := range contributions {
for currency := range balance {
currencies[currency] = 1
}
}
result := make(ledger.Balance)
for currency := range currencies {
result[currency] = getMonthlyAutoContributionRateForCurrency(contributions, window, currency)
}
return result
}
func getMonthlyAutoContributionRateForCurrency(contributions []ledger.Balance, window time.Duration, currency ledger.Currency) float64 {
values := []float64{}
for i := range contributions {
if v, ok := contributions[i][currency]; ok {
values = append(values, v)
}
}
slices.Sort(values)
if len(values) < 3 {
return 0
}
start := int(len(values) / 4)
end := min(1+max(0, len(values)-len(values)/4), len(values))
subvalues := values[start:end]
sum := 0.0
for _, v := range subvalues {
sum += v
}
standard := sum / float64(end-start)
standard = subvalues[len(subvalues)/2]
totalIfAllWereStandard := standard * float64(len(contributions))
result := totalIfAllWereStandard / float64(window) * float64(month)
//log.Printf("%s: %v contributions of about %.2f over %v can TLDR as %.2f per month from %v", currency, len(contributions), standard, window, result, values[start:end])
return result
}
func getRecentContributions(reg ledger.Register, window time.Duration) map[string][]ledger.Balance {
return getContributions(reg.Between(time.Now().Add(-1*window), time.Now()))
}
func getContributions(reg ledger.Register) map[string][]ledger.Balance {
contributions := make(map[string][]ledger.Balance)
for _, name := range reg.Names() {
contributions[name] = getContributionsFor(reg, name)
}
return contributions
}
func getContributionsFor(reg ledger.Register, name string) []ledger.Balance {
result := make([]ledger.Balance, 0)
var last ledger.Balance
for _, date := range reg.Dates() {
if _, ok := reg[date][name]; !ok {
continue
}
if last == nil {
last = reg[date][name]
continue
}
result = append(result, make(ledger.Balance))
this := result[len(result)-1]
for k, v := range last {
this[k] = -1 * v
}
for k, v := range reg[date][name] {
this[k] += v
}
last = reg[date][name]
}
return result
}

129
src/ana/predictor_test.go Normal file
View File

@@ -0,0 +1,129 @@
package ana
import (
"testing"
"time"
"gogs.inhome.blapointe.com/ana-ledger/src/ledger"
)
func TestNewInterestPredictor(t *testing.T) {
acc := "x"
curr := ledger.USD
cases := map[string]struct {
apy float64
given ledger.Balances
delta time.Duration
want ledger.Balances
}{
"zero": {
apy: 0,
given: ledger.Balances{acc: ledger.Balance{curr: 100}},
delta: time.Hour * 24 * 365,
want: ledger.Balances{acc: ledger.Balance{curr: 100}},
},
"50%": {
apy: .5,
given: ledger.Balances{acc: ledger.Balance{curr: 100}},
delta: time.Hour * 24 * 365,
want: ledger.Balances{acc: ledger.Balance{curr: 163.21}},
},
}
for name, d := range cases {
c := d
t.Run(name, func(t *testing.T) {
predictor := NewInterestPredictor(acc, string(curr), c.apy)
got := predictor(c.given, c.delta)
if got.Debug() != c.want.Debug() {
t.Errorf("want\n\t%+v, got\n\t%+v", c.want, got)
}
})
}
}
func TestGetContributions(t *testing.T) {
input := ledger.Register{
"2001-01": ledger.Balances{
"a": ledger.Balance{"x": 1},
"b": ledger.Balance{"z": 1},
},
"2001-02": ledger.Balances{
"a": ledger.Balance{"y": 1},
},
"2001-03": ledger.Balances{
"b": ledger.Balance{"z": 4},
},
}
got := getContributions(input)
t.Logf("%+v", got)
if len(got) != 2 {
t.Error(len(got))
}
if len(got["a"]) != 1 {
t.Error(len(got["a"]))
} else if len(got["a"][0]) != 2 {
t.Error(got["a"])
} else if got["a"][0]["x"] != -1 {
t.Error(got["a"][0])
} else if got["a"][0]["y"] != 1 {
t.Error(got["a"][0])
}
if len(got["b"]) != 1 {
t.Error(len(got["b"]))
} else if len(got["b"][0]) != 1 {
t.Error(got["b"])
} else if got["b"][0]["z"] != 3 {
t.Error(got["b"][0])
}
}
func TestGetMonthlyAutoContributionRate(t *testing.T) {
input := []ledger.Balance{
ledger.Balance{"x": 2},
ledger.Balance{"x": 4},
ledger.Balance{"y": 3},
}
got := getMonthlyAutoContributionRate(input, time.Hour*24*365/4)
if len(got) != 2 {
t.Error(got)
}
if got["x"] != 0 { // too few contribution
t.Error(got["x"])
}
if got["y"] != 0 { // too few contribution
t.Error(got["y"])
}
}
func TestNewContributionPredictor(t *testing.T) {
name := "x"
currency := ledger.USD
predictor := NewContributionPredictor(map[string]ledger.Balance{
name: {currency: 10},
"y": {"XYZ": 3},
})
month := time.Hour * 24 * 365 / 12
if got := predictor(ledger.Balances{}, 2*month); got[name][currency] != 20 {
t.Error(got[name])
} else if got["y"]["XYZ"] != 6 {
t.Error(got["y"])
}
if got := predictor(ledger.Balances{name: {currency: 30}}, 2*month); got[name][currency] != 30+20 {
t.Error(got)
} else if got["y"]["XYZ"] != 6 {
t.Error(got["y"])
}
if got := predictor(ledger.Balances{"z": {"ABC": 100}}, 2*month); got[name][currency] != 20 {
t.Error(got)
} else if got["y"]["XYZ"] != 6 {
t.Error(got["y"])
} else if got["z"]["ABC"] != 100 {
t.Error(got["z"])
}
}

36
src/ana/window.go Normal file
View File

@@ -0,0 +1,36 @@
package ana
import (
"fmt"
"time"
)
func predictionTimes(window time.Duration) []time.Time {
result := []time.Time{time.Now()}
last := time.Now()
for last.Before(time.Now().Add(window)) {
last = last.Add(-1 * time.Hour * 24 * time.Duration(last.Day())).Add(time.Hour * 24 * 33)
result = append(result, last)
}
return result
}
func mustDateToTime(s string) time.Time {
result, err := dateToTime(s)
if err != nil {
panic(err)
}
return result
}
func dateToTime(s string) (time.Time, error) {
for _, layout := range []string{
"2006-01-02",
"2006-01",
} {
if t, err := time.ParseInLocation(layout, s, time.Local); err == nil {
return t, err
}
}
return time.Time{}, fmt.Errorf("no layout matching %q", s)
}