Can you provide a concrete method for generating list and symitems, or at least some more specifics about their dimensions. I can't test without some data.

Hi Eric,

The attached file should be enough to allow you to test things out. This example is relatively fast, but still slow enough to get a feel for what the problem is. The goal is to end up with 1 member of each subgroup without a priori knowledge of how many subgroups there are (which rules out the use of Intersection and Complement - the order of items in list needs to be preserved, which neither of those functions do).

Attachments:

ExampleCode.nb

Hi Eric,

Definitely not

PermRules[list_] := Map[Thread[Rule[list, #]] &, Permutations@list, {-2}]

unless I'm misunderstanding (why just the second to last position, AKA {-2}?). I'm a day into running my code, so I can't test this right now (my list is 5118 rows long, with each symitems containing 11520 rows).

Best thing to do to see what is happening is to add

Print["vars: ", MatrixForm@vars]

after the local variables have been defined,

Print["symelement: ", MatrixForm@symelement]

after "symelement=...;" , and "Print["Result: ",MatrixForm@Result]" between "Remove[...];" and "Result" in PermRules[vars_].

I might be able to do Result=Flatten[Tuples[symelement, 4],1]. In many situations Tuples has caused me lots of problems when the output is large, so I tend to avoid using it.

Thanks for looking into this.
Troy

Hi Eric,

I don't know. As I said I'm not at a point where I can test it and won't be able to for a few days at the rate things are running. If you do

vars=Variables@list; 
lvars = {PolyCoefList3 \[Intersection] vars, 
   PolyCoefList4 \[Intersection] vars, 
   PolyPowerList3 \[Intersection] vars, 
   PolyPowerList4 \[Intersection] vars};
symgroup = PowSym[lvars];

with your version of PowSym and get exactly the same result as using my version of PowSym, then PowSymmetryCheck1 will work correctly.

In any event, PowSym works correctly and is acceptably fast as written. In fact, the code is acceptably fast everywhere except for the two spots with

If[MemberQ[symitems, list[[#]]], {}, list[[#]]] & /@ Range[2, len]

and

If[MemberQ[symitems, temp1[[#]]], {}, temp1[[#]]] & /@ 
 Range[i + 1, len]

which I'd like to replace with some sort of parallelized function.

That is the short example.

Eric, I appreciate your time trying to answer my question, but

..."symitems" are all possible symmetry mappings (which range from S(2)xS(2)xS(2)xS(1) to S(5)xS(5)xS(5)xS(4)) of "list[[1]]."

is the description of the problem, which was included in my original post. I also said I only need one member of each subgroup. If you do not know what that means, you could have asked for clarification. Elsewhere I create raw data, "list," that can contain multiple members of subgroups when I only need one from each subgroup. S(n) is the n-permutation group, in this case the permutation group mapping a set of labels within itself. The fact that I have the product of 4 symmetry groups means that I have 4 sets of labels. As for what "list" represents, that is immaterial to the issue I wish help with.

I did not say that I would not test your ideas, just that I was not at a point where I could do it now. When I'm at a breaking point, I will try the Tuples approach since built-in code is always faster than interpreted code.

I asked a specific question regarding parallelization in a line of code because that line of code is the slowest part of the process and, to me, there is no obvious reason why parallelization is resulting in a considerably slower process than the serial process. That means I've already gone through the code, identified the bottleneck, and considered alternatives (besides re-ordering lists, both intersection and complement also change their length which is a serious problem when one is running a loop based on how long a list is).

I've tried to indulge your process for approaching problems while biting my tongue for your arrogance of second guessing me. This is not the first time I've had someone in this community insist on solving every other problem but what I asked for, and it is very annoying.

I solved the problem, though it took a complex solution. In the end I got a method that was 2 at least twice as fast as the original serial version and >10x the parallel one.