tests and refactoring

Author: oursimon

internal/weights/weights.go

@@ -8,10 +8,8 @@ import (
 
 const NOT_SELECTED_WEIGHT = -2
 
-// WEIGHT_SATURATION_LIMIT is set to 2^30.
-// Weights for periods and selected variables increase exponentially
-// with the number of periods and selections.
-const WEIGHT_SATURATION_LIMIT = 1073741824
+// WEIGHTS_SATURATION_LIMIT is set to 2^32.
+const WEIGHTS_SATURATION_LIMIT = 4294967296
 
 type Weights map[string]int
 
@@ -44,8 +42,9 @@ func (w Weights) absMaxWeight() int {
 	return maxWeight
 }
 
-func (w Weights) ContainsTooLargeWeight() bool {
-	tooLarge := w.absMaxWeight() > WEIGHT_SATURATION_LIMIT
+func (w Weights) WeightsToLarge() bool {
+	sum := w.sum()
+	tooLarge := abs(sum) > WEIGHTS_SATURATION_LIMIT
 	return tooLarge
 }
 
@@ -68,13 +67,13 @@ func Calculate(
 		notSelectedSum,
 		preferredSum,
 	)
-	absMaxPeriodWeight := periodWeights.absMaxWeight()
+	maxPeriodWeight := periodWeights.absMaxWeight()
 
 	selectedWeights := calculateSelectedWeights(
 		selections,
 		notSelectedSum,
 		preferredSum,
-		absMaxPeriodWeight,
+		maxPeriodWeight,
 	)
 
 	weights := notSelectedWeights.
@@ -114,15 +113,21 @@ func calculatePreferredWeights(
 
 func calculatePeriodWeights(
 	periodIDs []string,
-	notSelectedSum,
-	preferredSum int,
+	notSelectedSum int,
+	preferredWeightsSum int,
 ) Weights {
 	periodWeights := make(Weights)
 
-	threshold := -absSum(notSelectedSum, preferredSum)
+	threshold := -absSum(notSelectedSum, preferredWeightsSum)
 
 	periodWeightSum := threshold
-	for _, periodID := range periodIDs {
+	for i, periodID := range periodIDs {
+		if i == 0 {
+			periodWeights[periodID] = 0
+
+			continue
+		}
+
 		weight := periodWeightSum - 1
 		periodWeights[periodID] = weight
 		periodWeightSum += weight
@@ -135,11 +140,11 @@ func calculateSelectedWeights(
 	selections Selections,
 	notSelectedSum,
 	preferredWeightsSum int,
-	absMaxPeriodWeight int,
+	maxPeriodWeight int,
 ) Weights {
 	selectedWeights := make(Weights)
 
-	threshold := absSum(notSelectedSum, preferredWeightsSum, absMaxPeriodWeight)
+	threshold := absSum(notSelectedSum, preferredWeightsSum, maxPeriodWeight)
 
 	selectionWeightSum := threshold
 	for _, selection := range selections {

internal/weights/weights_test.go

@@ -280,9 +280,11 @@ func Test_absSum(t *testing.T) {
 		terms    []int
 		expected int
 	}{
-		{terms: []int{1, -2, 3}, expected: 6},
-		{terms: []int{-1, -2, -3}, expected: 6},
+		{terms: []int{}, expected: 0},
 		{terms: []int{0, 0, 0}, expected: 0},
+		{terms: []int{-1, -2, -3}, expected: 6},
+		{terms: []int{1, 2, 3}, expected: 6},
+		{terms: []int{-1, -2, -3}, expected: 6},
 	}
 
 	for _, theory := range theories {
@@ -308,26 +310,26 @@ func Test_calculatePeriodWeights(t *testing.T) {
 			name:      "given periodIDs and zero notSelectedSum and preferredSum",
 			periodIDs: []string{"a", "b"},
 			want: Weights{
-				"a": -1,
-				"b": -2,
+				"a": 0,
+				"b": -1,
 			},
 		},
 		{
 			name:           "given periodIDs and non-zero positive notSelectedSum",
 			periodIDs:      []string{"a", "b"},
 			notSelectedSum: 1,
 			want: Weights{
-				"a": -2,
-				"b": -4,
+				"a": 0,
+				"b": -2,
 			},
 		},
 		{
 			name:           "given periodIDs and non-zero negative notSelectedSum",
 			periodIDs:      []string{"a", "b"},
 			notSelectedSum: -1,
 			want: Weights{
-				"a": -2,
-				"b": -4,
+				"a": 0,
+				"b": -2,
 			},
 		},
 		{
@@ -336,8 +338,8 @@ func Test_calculatePeriodWeights(t *testing.T) {
 			notSelectedSum: -1,
 			preferredSum:   -2,
 			want: Weights{
-				"a": -4,
-				"b": -8,
+				"a": 0,
+				"b": -4,
 			},
 		},
 	}

puan/solution_creator.go

@@ -70,7 +70,7 @@ func (c *SolutionCreator) findDependentSolution(
 		return SolutionEnvelope{}, err
 	}
 
-	tooLarge := query.weights.ContainsTooLargeWeight()
+	tooLarge := query.weights.WeightsToLarge()
 
 	solution, err := c.Solve(query)
 	if err != nil {

tests/integration_tests/solve/period_test.go

@@ -4,8 +4,10 @@ import (
 	"testing"
 	"time"
 
+	"github.com/go-faker/faker/v4/pkg/options"
 	"github.com/stretchr/testify/assert"
 
+	"github.com/ourstudio-se/puan-sdk-go/internal/fake"
 	"github.com/ourstudio-se/puan-sdk-go/puan"
 )
 
@@ -454,3 +456,121 @@ func Test_givenTimeEnabledWithoutTimeboundConstraints_andLateFromSpecified_shoul
 	_, err := solutionCreator.Create(nil, ruleset, &afterEnd)
 	assert.Error(t, err)
 }
+
+// Global XOR rule for item1 and item2,
+// item2 has many consequences in the first period.
+// The solver should choose the first period when item2 is selected.
+func Test_givenXORWithManyConsequencesInFirstPeriod_shouldChooseFirstPeriod(t *testing.T) {
+	creator := puan.NewRulesetCreator()
+	startTime := time.Now()
+	endTime := startTime.Add(1 * time.Hour)
+	_ = creator.EnableTime(startTime, endTime)
+
+	item1 := fake.New[string]()
+	item2 := fake.New[string]()
+	_ = creator.AddPrimitives(item1, item2)
+	xorID, _ := creator.SetXor(item1, item2)
+	_ = creator.Assume(xorID)
+
+	item2Consequences := fake.New[[]string](
+		func(oo *options.Options) {
+			oo.RandomMinSliceSize = 50
+			oo.RandomMaxSliceSize = 50
+		},
+	)
+	_ = creator.AddPrimitives(item2Consequences...)
+
+	andID, _ := creator.SetAnd(item2Consequences...)
+	item2Implies, _ := creator.SetImply(item2, andID)
+
+	endOfFirstPeriod := startTime.Add(30 * time.Minute)
+	_ = creator.AssumeInPeriod(item2Implies, startTime, endOfFirstPeriod)
+
+	ruleset, _ := creator.Create()
+
+	envelope, _ := solutionCreator.Create(
+		puan.Selections{
+			puan.NewSelectionBuilder(item2).Build(),
+		},
+		ruleset,
+		&startTime,
+	)
+
+	solution := envelope.Solution()
+
+	asserter := newSolutionAsserter(solution)
+	asserter.assertActive(t, item2)
+	asserter.assertActive(t, "period_0")
+	asserter.assertActive(t, item2Consequences...)
+	asserter.assertInactive(t, item1)
+	asserter.assertInactive(t, "period_1")
+}
+
+// Global XOR rules for item1 and many other items,
+// all other items are preferred in the first period.
+// The solver should choose the first period when item1 is selected.
+func Test_givenXORWithManyPreferredInFirstPeriod_shouldChooseFirstPeriod(t *testing.T) {
+	creator := puan.NewRulesetCreator()
+	startTime := time.Now()
+	endTime := startTime.Add(1 * time.Hour)
+	_ = creator.EnableTime(startTime, endTime)
+
+	item1 := fake.New[string]()
+	_ = creator.AddPrimitives(item1)
+
+	otherItems := fake.New[[]string](
+		func(oo *options.Options) {
+			oo.RandomMinSliceSize = 50
+			oo.RandomMaxSliceSize = 50
+		},
+	)
+	_ = creator.AddPrimitives(otherItems...)
+
+	endOfFirstPeriod := startTime.Add(30 * time.Minute)
+	for _, otherItem := range otherItems {
+		xorID, _ := creator.SetXor(item1, otherItem)
+		_ = creator.Assume(xorID)
+		preferredOtherItem, _ := creator.SetImply(xorID, otherItem)
+		_ = creator.PreferInPeriod(preferredOtherItem, startTime, endOfFirstPeriod)
+	}
+
+	ruleset, _ := creator.Create()
+
+	envelope, _ := solutionCreator.Create(
+		puan.Selections{
+			puan.NewSelectionBuilder(item1).Build(),
+		},
+		ruleset,
+		&startTime,
+	)
+
+	solution := envelope.Solution()
+
+	asserter := newSolutionAsserter(solution)
+	asserter.assertActive(t, item1)
+	asserter.assertActive(t, "period_0")
+	asserter.assertInactive(t, otherItems...)
+	asserter.assertInactive(t, "period_1")
+}
+
+type solutionAsserter struct {
+	puan.Solution
+}
+
+func newSolutionAsserter(solution puan.Solution) solutionAsserter {
+	return solutionAsserter{solution}
+}
+
+func (s solutionAsserter) assertActive(t *testing.T, variables ...string) {
+	solution := s.Extract(variables...)
+	for variable, value := range solution {
+		assert.Equal(t, 1, value, "expected %s to be active", variable)
+	}
+}
+
+func (s solutionAsserter) assertInactive(t *testing.T, variables ...string) {
+	solution := s.Extract(variables...)
+	for variable, value := range solution {
+		assert.Equal(t, 0, value, "expected %s to be inactive", variable)
+	}
+}