ctrl + f

Author: mtf90

algorithms/active/sparse/src/main/java/de/learnlib/algorithm/sparse/CoreRow.java

@@ -23,8 +23,7 @@
 import net.automatalib.word.Word;
 
 /**
- * Each core row represents some hypothesis state
- * and stores its outputs for all table suffixes.
+ * Each core row represents some hypothesis state and stores its outputs for all table suffixes.
  */
 class CoreRow<S, I, O> extends Row<S, I, O> {
 
@@ -34,8 +33,7 @@ class CoreRow<S, I, O> extends Row<S, I, O> {
     final S state;
 
     /**
-     * Index of this row in the core row list.
-     * Used as a unique address.
+     * Index of this row in the core row list. Used as a unique address.
      */
     final int idx;
 
@@ -45,8 +43,7 @@ class CoreRow<S, I, O> extends Row<S, I, O> {
     final Map<Word<I>, Word<O>> sufToOut;
 
     /**
-     * Identifiers of all suffix-output pairs in this row,
-     * used for fast compatibility checking.
+     * Identifiers of all suffix-output pairs in this row, used for fast compatibility checking.
      */
     final Set<Integer> cellIds;
 

algorithms/active/sparse/src/main/java/de/learnlib/algorithm/sparse/FringeRow.java

@@ -18,8 +18,7 @@
 import net.automatalib.word.Word;
 
 /**
- * Each fringe row represents some hypothesis transition
- * outside the spanning tree defined by the core prefixes.
+ * Each fringe row represents some hypothesis transition outside the spanning tree defined by the core prefixes.
  *
  * @param <S>
  *         state type
@@ -46,9 +45,8 @@ class FringeRow<S, I, O> extends Row<S, I, O> {
     O transOut;
 
     /**
-     * For compression, fringe rows do not store observations directly.
-     * Instead, they point to some leaf in a tree encoding their classification history.
-     * This trick avoids redundantly storing identical observations.
+     * For compression, fringe rows do not store observations directly. Instead, they point to some leaf in a tree
+     * encoding their classification history. This trick avoids redundantly storing identical observations.
      */
     Leaf<S, I, O> leaf;
 

algorithms/active/sparse/src/main/java/de/learnlib/algorithm/sparse/GenericSparseLearner.java

@@ -62,8 +62,8 @@ class GenericSparseLearner<S, I, O> implements MealyLearner<I, O> {
     private final Map<Word<I>, FringeRow<S, I, O>> prefToFringe;
 
     /**
-     * List of unique suffix-output pairs, addressable by index.
-     * Used for table compression: table entries only hold cell index.
+     * List of unique suffix-output pairs, addressable by index. Used for table compression: table entries only hold
+     * cell index.
      */
     private final List<Pair<Word<I>, Word<O>>> cells;
 
@@ -257,8 +257,7 @@ private Word<O> query(Row<S, I, O> r, Word<I> suf) {
     }
 
     /**
-     * Adds suffix-output pair to index if not yet contained,
-     * and returns a unique identifier representing the pair.
+     * Adds suffix-output pair to index if not yet contained, and returns a unique identifier representing the pair.
      */
     private int getUniqueCellIdx(Word<I> suf, Word<O> out) {
         assert suf.length() == out.length();
@@ -296,8 +295,8 @@ private int moveToCore(FringeRow<S, I, O> f, List<Integer> cellIds) {
     }
 
     /**
-     * Takes fringe row and its observations, queries the missing entries,
-     * and returns a list containing the observations for all suffixes.
+     * Takes fringe row and its observations, queries the missing entries, and returns a list containing the
+     * observations for all suffixes.
      */
     private List<Integer> completeRowObservations(FringeRow<S, I, O> f, List<Integer> cellIds) {
         final List<Word<I>> sufsPresent = cellIds.stream().map(c -> this.cells.get(c).getFirst()).toList();

algorithms/active/sparse/src/main/java/de/learnlib/algorithm/sparse/Leaf.java

@@ -21,27 +21,25 @@
 import org.checkerframework.checker.nullness.qual.Nullable;
 
 /**
- * Leaves can be split or unsplit.
- * An unsplit leaf has a single compatible core row to which it points.
- * As new core rows emerge, the observations of the leaf may not suffice
- * anymore to uniquely assign it to some core row. Then, it becomes split.
- * Split leaves cache suffix selection by reference to separators.
- * Leaves remember how many core rows and suffixes existed at their last visit.
- * This information is used as a logical timestamp to check
- * if the separator is still known to be optimal
- * or if it needs to be recomputed.
+ * Leaves can be split or unsplit. An unsplit leaf has a single compatible core row to which it points. As new core rows
+ * emerge, the observations of the leaf may not suffice anymore to uniquely assign it to some core row. Then, it becomes
+ * split. Split leaves cache suffix selection by reference to separators. Leaves remember how many core rows and
+ * suffixes existed at their last visit. This information is used as a logical timestamp to check if the separator is
+ * still known to be optimal or if it needs to be recomputed.
  */
 class Leaf<S, I, O> extends Node<S, I, O> {
 
     /**
      * Core row associated with this leaf (null if split, see {@link Leaf}).
      */
-    @Nullable CoreRow<S, I, O> cRow;
+    @Nullable
+    CoreRow<S, I, O> cRow;
 
     /**
      * Separator cached by this leaf (see {@link Leaf}).
      */
-    @Nullable Separator<S, I, O> sep;
+    @Nullable
+    Separator<S, I, O> sep;
 
     private int lastNumCRows;
     private int lastNumSufs;
@@ -62,8 +60,7 @@ private Leaf(int numCRows, int numSufs, List<Integer> cellIds) {
     }
 
     /**
-     * Creates unsplit leaf associated with the given core row and observations
-     * (see {@link Leaf}).
+     * Creates unsplit leaf associated with the given core row and observations (see {@link Leaf}).
      */
     Leaf(CoreRow<S, I, O> cRow, int numCRows, int numSufs, List<Integer> cellIds) {
         this(numCRows, numSufs, cellIds);

algorithms/active/sparse/src/main/java/de/learnlib/algorithm/sparse/Node.java

@@ -19,11 +19,9 @@
 import java.util.List;
 
 /**
- * For table compression and to cache suffix selection,
- * fringe rows do not store observations, but instead map to some node.
- * Each node is associated with a set of suffix-output pairs,
- * potentially representing multiple rows with identical observations.
- * Nodes are either leaves or separators.
+ * For table compression and to cache suffix selection, fringe rows do not store observations, but instead map to some
+ * node. Each node is associated with a set of suffix-output pairs, potentially representing multiple rows with
+ * identical observations. Nodes are either leaves or separators.
  */
 class Node<S, I, O> { // type parameters required for safe casting
 
@@ -33,9 +31,8 @@ class Node<S, I, O> { // type parameters required for safe casting
     final List<Integer> cellIds;
 
     /**
-     * Bit vector encoding which core rows remain compatible
-     * with the observations at this node.
-     * Rows are represented by their index.
+     * Bit vector encoding which core rows remain compatible with the observations at this node. Rows are represented by
+     * their index.
      */
     final BitSet remRows;
 

algorithms/active/sparse/src/main/java/de/learnlib/algorithm/sparse/Row.java

@@ -18,6 +18,7 @@
 import net.automatalib.word.Word;
 
 class Row<S, I, O> { // type parameters required for safe casting
+
     final Word<I> prefix;
 
     protected Row(Word<I> prefix) {

algorithms/active/sparse/src/main/java/de/learnlib/algorithm/sparse/Separator.java

@@ -23,12 +23,11 @@
 import net.automatalib.word.Word;
 
 /**
- * Separators guide the classification of fringe prefixes.
- * A separator holds a suffix and a branch map.
- * The map points to the next node,
- * depending on the output produced by the suffix.
+ * Separators guide the classification of fringe prefixes. A separator holds a suffix and a branch map. The map points
+ * to the next node, depending on the output produced by the suffix.
  */
 class Separator<S, I, O> extends Node<S, I, O> {
+
     final Word<I> suffix;
     final Map<Word<O>, Node<S, I, O>> branchMap;