ENHANCE: Avoid memory churning in solvable conjugacy classes routine.

Reduce assertion level in test, as the many tests otherwise make it unusable

lib/claspcgs.gi

@@ -326,6 +326,7 @@ local  classes,    # classes to be constructed, the result
 	depthlev,   # depth at which N starts
 	one,zero,
 	vec,
+        dict,
 	kern,img;
 
     depthlev:=DepthOfPcElement(home,N[1]);
@@ -465,20 +466,28 @@ local  classes,    # classes to be constructed, the result
       #k:=ExternalOrbitsStabilizers( xset );
 
       # do the orbits stuff ourselves
-      blist:=BlistList([1..Length(aff)],[]);
+      dict:=NewDictionary(aff[1],true,aff); # keep the dictionary to avoid
+                                            # recreating blist.
+
+      if not IsPositionDictionary(dict) then
+        blist:=BlistList([1..Length(aff)],[]);
+      else
+        blist:=dict!.blist;
+      fi;
       next:=1;
       k:=[];
       while next<>fail do
-        S:=Pcs_OrbitStabilizer(gens,aff,aff[next],imgs,OnRight);
-	# tick off
-	if IsPositionDictionary(S.dictionary) then
-	  UniteBlist(blist,S.dictionary!.blist);
-	else
+	if IsPositionDictionary(dict) then
+          S:=Pcs_OrbitStabilizer(gens,aff,aff[next],imgs,OnRight,dict);
+          #S.dictionary!.vals:=[]; #Not really that expensive to keep
+        else
+          S:=Pcs_OrbitStabilizer(gens,aff,aff[next],imgs,OnRight);
 	  for i in S.orbit do
 	    blist[PositionCanonical(aff,i)]:=true;
 	  od;
 	fi;
 	Unbind(S.dictionary);
+        S.orbit:=S.orbit{[1]}; # save memory
 
 	Add(k,S);
 

lib/oprtpcgs.gi

@@ -9,8 +9,11 @@
 ##  SPDX-License-Identifier: GPL-2.0-or-later
 ##
 
-InstallGlobalFunction(Pcs_OrbitStabilizer,function(pcgs,D,pnt,acts,act)
-local   orb,             # orbit
+#function(pcgs,D,pnt,acts,act[,dict]) -- allow to reuse dictionary
+# in case of many short orbits
+InstallGlobalFunction(Pcs_OrbitStabilizer,function(arg)
+local   pcgs,D,pnt,acts,act,
+        orb,             # orbit
 	len,             # lengths of orbit before each extension
 	d,		 # dictionary
 	S, rel,   # stabilizer and induced pcgs
@@ -19,8 +22,14 @@ local   orb,             # orbit
 	depths,          # depths of stabilizer generators
 	i, ii, j, k;     # loop variables
 
+  pcgs:=arg[1];D:=arg[2];pnt:=arg[3];acts:=arg[4];act:=arg[5];
+
   pnt:=Immutable(pnt);
-  d:=NewDictionary(pnt,true,D);
+  if Length(arg)>5 then
+    d:=arg[6];
+  else
+    d:=NewDictionary(pnt,true,D);
+  fi;
   orb := [ pnt ];
   AddDictionary(d,pnt,1);
   len := ListWithIdenticalEntries( Length( pcgs ) + 1, 0 );

tst/teststandard/permgrp.tst

@@ -31,6 +31,27 @@ gap> dc1:=DoubleCosetRepsAndSizes(g,s,s:sisyphus);;
 gap> Collected(List(dc,x->x[2]))=Collected(List(dc1,x->x[2]));
 true
 
+# The purpose of the following test is to test groups with a large number
+# of classes.  The assertions for checking the classes will slow the
+# calculation down beyond usability, thus change assertion level
+gap> SetAssertionLevel(1);
+gap> g:=Group((1,27,22,31,13,3,25,24,29,16)(2,28,21,32,14,4,26,23,30,15)
+> (5,17,37,43,33,8,19,40,41,35)(6,18,38,44,34,7,20,39,42,36)(9,12)
+> (10,11), (1,20,21,33,26,2,19,22,34,25)(3,17,23,35,28)(4,18,24,36,27)
+> (5,30,14,12,42)(6,29,13,11,41)(7,31,16,9,43)(8,32,15,10,44));;
+gap> IsSolvableGroup(g);
+true
+gap> Sum(ConjugacyClasses(g),Size);
+461373440
+gap> g:=Group((1,2,4,3)(5,9,20,36,24,41,37,30,15,27,6,11,19,34,23,43,38,
+> 32,16,25)(7,10,18,35,22,42,39,29,13,28,8,12,17,33,21,44,40,31,14,26),
+> (1,20,38,30,42)(2,17,40,29,43,3,19,39,32,41,4,18,37,31,44)
+> (5,36,13,23,10,6,33,15,24,11,8,34,14,22,12)(7,35,16,21,9)(25,27,28));;
+gap> IsSolvableGroup(g);
+true
+gap> Sum(ConjugacyClasses(g),Size);
+1384120320
+
 # Unbind variables so we can GC memory
 gap> Unbind(g); Unbind(dc); Unbind(ac); Unbind(g); Unbind(p); Unbind(s);
 gap> STOP_TEST( "permgrp.tst", 1);