From 4220b2af314201714c5a53e856dff8317557ba76 Mon Sep 17 00:00:00 2001 From: OszkarSemerath Date: Thu, 3 Aug 2023 19:16:03 +0200 Subject: Intermediate commit with Lazy NeighbourhoodCalculator and StateEquivalenceChecker prototypes --- .../store/statecoding/ExperimentalSetupTest.java | 107 +++++++++++++++++++++ .../store/statecoding/StateCoderBuildTest.java | 80 +++++++++++++++ 2 files changed, 187 insertions(+) create mode 100644 subprojects/store/src/test/java/tools/refinery/store/statecoding/ExperimentalSetupTest.java create mode 100644 subprojects/store/src/test/java/tools/refinery/store/statecoding/StateCoderBuildTest.java (limited to 'subprojects/store/src/test/java/tools') diff --git a/subprojects/store/src/test/java/tools/refinery/store/statecoding/ExperimentalSetupTest.java b/subprojects/store/src/test/java/tools/refinery/store/statecoding/ExperimentalSetupTest.java new file mode 100644 index 00000000..87b1623c --- /dev/null +++ b/subprojects/store/src/test/java/tools/refinery/store/statecoding/ExperimentalSetupTest.java @@ -0,0 +1,107 @@ +/* + * SPDX-FileCopyrightText: 2023 The Refinery Authors + * + * SPDX-License-Identifier: EPL-2.0 + */ +package tools.refinery.store.statecoding; + +import org.junit.jupiter.api.Test; +import tools.refinery.store.map.Version; +import tools.refinery.store.model.ModelStore; +import tools.refinery.store.representation.Symbol; +import tools.refinery.store.tuple.Tuple; + +import java.util.*; + +class ExperimentalSetupTest { + public static void generate(int size) { + Symbol person = new Symbol<>("Person", 1, Boolean.class, false); + Symbol friend = new Symbol<>("friend", 2, Boolean.class, false); + + var store = ModelStore.builder() + .symbols(person, friend) + .with(StateCoderAdapter + .builder()) + .build(); + + Set versions = new HashSet<>(); + Map> codes = new HashMap<>(); + + var empty = store.createEmptyModel(); + var pI = empty.getInterpretation(person); + + for (int i = 0; i < size; i++) { + pI.put(Tuple.of(i), true); + } + + var emptyVersion = empty.commit(); + versions.add(emptyVersion); + var emptyCode = empty.getAdapter(StateCoderAdapter.class).calculateModelCode(); + List emptyList = new ArrayList<>(); + emptyList.add(emptyVersion); + codes.put(emptyCode, emptyList); + + var storeAdapter = store.getAdapter(StateCoderStoreAdapter.class); + + int dif = 0; + int iso = 0; + int unk = 0; + + //int step = 0 + + for (int i = 0; i < size; i++) { + for (int j = 0; j < size; j++) { + var previousVersions = new HashSet<>(versions); + for (var version : previousVersions) { + + var model = store.createModelForState(version); + model.getInterpretation(friend).put(Tuple.of(i, j), true); + + Version version1 = model.commit(); + var stateCode = model.getAdapter(StateCoderAdapter.class).calculateStateCode(); + int code = stateCode.modelCode(); + //System.out.println(step+++" ->" +code); + if (codes.containsKey(code)) { + Version similar = codes.get(code).get(0); + + var outcome = storeAdapter.checkEquivalence(version1, similar); + if (outcome == StateEquivalenceChecker.EquivalenceResult.DIFFERENT) { + System.out.println(); + var c = model.getInterpretation(friend).getAll(); + while (c.move()) { + System.out.println(c.getKey().toString()); + } + System.out.println("vs"); + var c2 = store.createModelForState(similar).getInterpretation(friend).getAll(); + while (c2.move()) { + System.out.println(c2.getKey().toString()); + } + + dif++; + } else if (outcome == StateEquivalenceChecker.EquivalenceResult.UNKNOWN) { + unk++; + } else { + iso++; + } + } else { + versions.add(version1); + + List newList = new ArrayList<>(); + newList.add(version1); + codes.put(code, newList); + } + } + } + } + + System.out.printf("v=%d i=%d d=%d u=%d\n", versions.size(), iso, dif, unk); + } + + @Test + void runTests() { + for (int i = 0; i < 5; i++) { + System.out.println("size = " + i); + generate(i); + } + } +} diff --git a/subprojects/store/src/test/java/tools/refinery/store/statecoding/StateCoderBuildTest.java b/subprojects/store/src/test/java/tools/refinery/store/statecoding/StateCoderBuildTest.java new file mode 100644 index 00000000..b0b80af7 --- /dev/null +++ b/subprojects/store/src/test/java/tools/refinery/store/statecoding/StateCoderBuildTest.java @@ -0,0 +1,80 @@ +/* + * SPDX-FileCopyrightText: 2023 The Refinery Authors + * + * SPDX-License-Identifier: EPL-2.0 + */ +package tools.refinery.store.statecoding; + +import org.junit.jupiter.api.Test; +import tools.refinery.store.model.Interpretation; +import tools.refinery.store.model.ModelStore; +import tools.refinery.store.representation.Symbol; +import tools.refinery.store.tuple.Tuple; + +import static org.junit.jupiter.api.Assertions.*; + +class StateCoderBuildTest { + Symbol person = new Symbol<>("Person", 1, Boolean.class, false); + Symbol age = new Symbol<>("age", 1, Integer.class, null); + Symbol friend = new Symbol<>("friend", 2, Boolean.class, false); + + @Test + void simpleStateCoderTest() { + var store = ModelStore.builder() + .symbols(person, age, friend) + .with(StateCoderAdapter + .builder()) + .build(); + + var model = store.createEmptyModel(); + var stateCoder = model.getAdapter(StateCoderAdapter.class); + assertNotNull(stateCoder); + + var personI = model.getInterpretation(person); + var friendI = model.getInterpretation(friend); + var ageI = model.getInterpretation(age); + fill(personI, friendI, ageI); + + stateCoder.calculateStateCode(); + } + + @Test + void excludeTest() { + var store = ModelStore.builder() + .symbols(person, age, friend) + .with(StateCoderAdapter.builder() + .exclude(person) + .exclude(age)) + .build(); + + var model = store.createEmptyModel(); + var stateCoder = model.getAdapter(StateCoderAdapter.class); + assertNotNull(stateCoder); + + var personI = model.getInterpretation(person); + var friendI = model.getInterpretation(friend); + var ageI = model.getInterpretation(age); + fill(personI, friendI, ageI); + + int code = stateCoder.calculateStateCode().modelCode(); + + ageI.put(Tuple.of(1),3); + assertEquals(code,stateCoder.calculateStateCode().modelCode()); + + ageI.put(Tuple.of(1),null); + assertEquals(code,stateCoder.calculateStateCode().modelCode()); + + personI.put(Tuple.of(2),false); + assertEquals(code,stateCoder.calculateStateCode().modelCode()); + } + + private static void fill(Interpretation personI, Interpretation friendI, Interpretation ageI) { + personI.put(Tuple.of(1), true); + personI.put(Tuple.of(2), true); + + ageI.put(Tuple.of(1), 5); + ageI.put(Tuple.of(2), 4); + + friendI.put(Tuple.of(1, 2), true); + } +} -- cgit v1.2.3-70-g09d2