chore: more specific problem scale

core/src/build/revapi-differences.json

@@ -44,6 +44,13 @@
           "old": "field ai.timefold.solver.core.config.heuristic.selector.move.generic.AbstractPillarMoveSelectorConfig<Config_ extends ai.timefold.solver.core.config.heuristic.selector.move.generic.AbstractPillarMoveSelectorConfig<Config_>>.subPillarSequenceComparatorClass",
           "new": "field ai.timefold.solver.core.config.heuristic.selector.move.generic.AbstractPillarMoveSelectorConfig<Config_ extends ai.timefold.solver.core.config.heuristic.selector.move.generic.AbstractPillarMoveSelectorConfig<Config_>>.subPillarSequenceComparatorClass",
           "justification": "Internal protected fields; safe."
+        },
+        {
+          "ignore": true,
+          "code": "java.method.numberOfParametersChanged",
+          "old": "method void ai.timefold.solver.core.api.solver.ProblemSizeStatistics::<init>(long, long, long, double)",
+          "new": "method void ai.timefold.solver.core.api.solver.ProblemSizeStatistics::<init>(long, java.util.SequencedMap<java.lang.Class<?>, java.lang.Long>, long, long, java.util.SequencedMap<java.lang.Class<?>, java.util.SequencedMap<java.lang.String, java.lang.Long>>, double)",
+          "justification": "Type is not supposed to be constructed by user; safe."
         }
       ]
     }

core/src/main/java/ai/timefold/solver/core/api/solver/ProblemSizeStatistics.java

@@ -1,6 +1,7 @@
 package ai.timefold.solver.core.api.solver;
 
 import java.util.Locale;
+import java.util.SequencedMap;
 
 import ai.timefold.solver.core.impl.util.MathUtils;
 
@@ -17,8 +18,10 @@
  */
 @NullMarked
 public record ProblemSizeStatistics(long entityCount,
+        SequencedMap<Class<?>, Long> genuineEntityClassToEntityCount,
         long variableCount,
         long approximateValueCount,
+        SequencedMap<Class<?>, SequencedMap<String, Long>> genuineEntityClassToVariableToValueCount,
         double approximateProblemSizeLog) {
 
     /**

core/src/main/java/ai/timefold/solver/core/impl/domain/entity/descriptor/EntityDescriptor.java

@@ -814,4 +814,7 @@ public String toString() {
         return "%s(%s)".formatted(getClass().getSimpleName(), entityClass.getCanonicalName());
     }
 
+    public int getMaxVariableOrdinal() {
+        return effectiveVariableDescriptorMap.size();
+    }
 }

core/src/main/java/ai/timefold/solver/core/impl/score/director/ValueRangeStatistics.java

@@ -1,6 +1,8 @@
 package ai.timefold.solver.core.impl.score.director;
 
+import java.util.LinkedHashMap;
 import java.util.Objects;
+import java.util.SequencedMap;
 import java.util.function.Consumer;
 
 import ai.timefold.solver.core.api.solver.ProblemSizeStatistics;
@@ -28,6 +30,8 @@
 
     // Negative if not calculated, non-negative if cached
     private long cachedApproximateValueCount = -1L;
+    private long @Nullable [][] cachedValueCountByEntityAndVariableOrdinal;
+    private long @Nullable [] cachedEntityCountByEntityOrdinal;
     private double cachedProblemScale = -1.0;
 
     ValueRangeStatistics(ValueRangeManager<Solution_> valueRangeManager, SolutionDescriptor<Solution_> solutionDescriptor,
@@ -61,6 +65,18 @@
         var approximateValueCount = new MutableLong();
         var maxValueRangeSize = new MutableLong(0L);
 
+        cachedEntityCountByEntityOrdinal = new long[solutionDescriptor.getEntityDescriptors().size()];
+        cachedValueCountByEntityAndVariableOrdinal = new long[cachedEntityCountByEntityOrdinal.length][];
+        for (var entityDescriptor : solutionDescriptor.getEntityDescriptors()) {
+            // TimefoldTestResourceTest in Quarkus has an entity class with a basic variable
+            // that was not considered a genuine entity.
+            // (i.e. solutionDescriptor.getGenuineEntityDescriptors() did not have it).
+            // Are subclass entities that do not add new basic/list variable not considered
+            // genuine entities?
+            cachedValueCountByEntityAndVariableOrdinal[entityDescriptor.getOrdinal()] =
+                    new long[entityDescriptor.getMaxVariableOrdinal()];
+        }
+
         var listVariableDescriptor = solutionDescriptor.getListVariableDescriptor();
         if (listVariableDescriptor != null) {
             var countOnSolution =
@@ -69,6 +85,8 @@
             maxValueRangeSize.setValue(countOnSolution);
             if (listVariableDescriptor.canExtractValueRangeFromSolution()) {
                 approximateValueCount.add(countOnSolution);
+                cachedValueCountByEntityAndVariableOrdinal[listVariableDescriptor.getEntityDescriptor()
+                        .getOrdinal()][listVariableDescriptor.getOrdinal()] += countOnSolution;
             }
             if (!listVariableDescriptor.allowsUnassignedValues()) {
                 // We count every possibly unassigned element in every list variable.
@@ -81,6 +99,8 @@
             if (basicVariable.canExtractValueRangeFromSolution()) {
                 var countOnSolution = valueRangeManager.countOnSolution(basicVariable.getValueRangeDescriptor(), solution);
                 approximateValueCount.add(countOnSolution);
+                cachedValueCountByEntityAndVariableOrdinal[basicVariable.getEntityDescriptor().getOrdinal()][basicVariable
+                        .getOrdinal()] += countOnSolution;
                 if (maxValueRangeSize.longValue() < countOnSolution) {
                     maxValueRangeSize.setValue(countOnSolution);
                 }
@@ -94,6 +114,9 @@
             var entityDescriptor = solutionDescriptor.findEntityDescriptorOrFail(entity.getClass());
             if (entityDescriptor.isGenuine()) {
                 genuineEntityCount.increment();
+                // Should we include immovable entities for the count?
+                // Problem scale ignores them.
+                cachedEntityCountByEntityOrdinal[entityDescriptor.getOrdinal()]++;
                 var uninitializedVariableCountForEntity = entityDescriptor.countUninitializedVariables(entity);
                 if (uninitializedVariableCountForEntity > 0) {
                     uninitializedEntityCount.increment();
@@ -110,8 +133,11 @@
             for (var genuineVariable : entityDescriptor.getGenuineVariableDescriptorList()) {
                 if (genuineVariable instanceof BasicVariableDescriptor<Solution_> basicVariableDescriptor
                         && !basicVariableDescriptor.canExtractValueRangeFromSolution()) {
-                    approximateValueCount
-                            .add(valueRangeManager.countOnEntity(basicVariableDescriptor.getValueRangeDescriptor(), entity));
+                    var rangeValueCount =
+                            valueRangeManager.countOnEntity(basicVariableDescriptor.getValueRangeDescriptor(), entity);
+                    approximateValueCount.add(rangeValueCount);
+                    cachedValueCountByEntityAndVariableOrdinal[entityDescriptor.getOrdinal()][genuineVariable.getOrdinal()] +=
+                            rangeValueCount;
                 }
             }
             if (!entityDescriptor.hasAnyListVariables()) {
@@ -124,8 +150,10 @@
                 unassignedValueCount.subtract(countOnEntity);
             }
             if (!listVariableDescriptor.canExtractValueRangeFromSolution()) {
-                approximateValueCount
-                        .add(valueRangeManager.countOnEntity(listVariableDescriptor.getValueRangeDescriptor(), entity));
+                var listValueCount = valueRangeManager.countOnEntity(listVariableDescriptor.getValueRangeDescriptor(), entity);
+                approximateValueCount.add(listValueCount);
+                cachedValueCountByEntityAndVariableOrdinal[entityDescriptor.getOrdinal()][listVariableDescriptor
+                        .getOrdinal()] += listValueCount;
             }
             // TODO maybe detect duplicates and elements that are outside the value range
         });
@@ -152,10 +180,30 @@
             computeInitializationStatistics(null, false);
         }
         if (cachedProblemSizeStatistics == null) {
+            var entityClassToEntityCount = new LinkedHashMap<Class<?>, Long>();
+            var entityClassToVariableToValueCount = new LinkedHashMap<Class<?>, SequencedMap<String, Long>>();
+            for (var entityDescriptor : solutionDescriptor.getGenuineEntityDescriptors()) {
+                entityClassToEntityCount.put(entityDescriptor.getEntityClass(),
+                        cachedEntityCountByEntityOrdinal[entityDescriptor.getOrdinal()]);
+                var variableToValueCount = new LinkedHashMap<String, Long>();
+                for (var variableDescriptor : entityDescriptor.getBasicVariableDescriptorList()) {
+                    variableToValueCount.put(variableDescriptor.getVariableName(),
+                            cachedValueCountByEntityAndVariableOrdinal[entityDescriptor.getOrdinal()][variableDescriptor
+                                    .getOrdinal()]);
+                }
+                if (entityDescriptor.hasAnyListVariables()) {
+                    variableToValueCount.put(entityDescriptor.getListVariableDescriptor().getVariableName(),
+                            cachedValueCountByEntityAndVariableOrdinal[entityDescriptor.getOrdinal()][entityDescriptor
+                                    .getListVariableDescriptor().getOrdinal()]);
+                }
+                entityClassToVariableToValueCount.put(entityDescriptor.getEntityClass(), variableToValueCount);
+            }
             cachedProblemSizeStatistics = new ProblemSizeStatistics(
                     solutionDescriptor.getGenuineEntityCount(solution),
+                    entityClassToEntityCount,
                     solutionDescriptor.getGenuineVariableCount(solution),
                     cachedApproximateValueCount,
+                    entityClassToVariableToValueCount,
                     cachedProblemScale);
         }
         return cachedProblemSizeStatistics;

core/src/main/java/ai/timefold/solver/core/impl/solver/DefaultSolver.java

@@ -220,6 +220,22 @@ public void solvingStarted(SolverScope<Solution_> solverScope) {
                     problemSizeStatistics.entityCount(), problemSizeStatistics.variableCount(),
                     problemSizeStatistics.approximateValueCount(),
                     problemSizeStatistics.approximateProblemScaleAsFormattedString());
+            if (logger.isDebugEnabled()) {
+                var genuineEntityClassCountEntries = problemSizeStatistics.genuineEntityClassToEntityCount().entrySet();
+                for (var genuineEntityCountEntry : genuineEntityClassCountEntries) {
+                    var geninueEntityClass = genuineEntityCountEntry.getKey();
+                    logger.debug("    Entity ({}) count: {}",
+                            geninueEntityClass.getCanonicalName(),
+                            genuineEntityCountEntry.getValue());
+                    for (var geninueVariableEntry : problemSizeStatistics
+                            .genuineEntityClassToVariableToValueCount()
+                            .get(geninueEntityClass).entrySet()) {
+                        var genuineVariable = geninueVariableEntry.getKey();
+                        logger.debug("        Variable ({}) estimated value count: {}",
+                                genuineVariable, geninueVariableEntry.getValue());
+                    }
+                }
+            }
         }
     }