-----BEGIN PGP SIGNED MESSAGE-----
Hash: SHA1
NotDashEscaped: You need GnuPG to verify this message

Bart Cremers schreef:

Indeed:-)

Could you post a complete code

My pleasure, should?ve done that from the start, I guess.  The
additional class SignatureSymbol is just a wrapper around a String
(getName) and an int (getArity), whereas FunctionInputTuple is a wrapper
around a SignatureSymbol and a list of States, which checks that the
length of the list is the same as the symbol?s arity.  State is a class
that does nothing special except existing.

FunctionInputTuple.getInstance(symbol, states) is a factory method.  It
returns the single instance with the given symbol and states.  (Sort of
cache management).

import java.util.*;

/**
* A class representing a signature of an automaton.  It holds the
alphabet of
* symbols on which the automaton works.  Signatures are immutable.
*/
public class Signature implements Iterable<SignatureSymbol> {

/**
* Initialise a new signature, with given set of symbols.
*
* @param symbols
*/
public Signature(Set<SignatureSymbol> symbols) {
 this.symbols = new ArrayList<SignatureSymbol>(symbols);
 Collections.sort(this.symbols, new Comparator<SignatureSymbol>() {

   public int compare(SignatureSymbol sym1, SignatureSymbol sym2) {
     return sym1.getArity() - sym2.getArity();
   }

 });
}

/**
* The symbols of the signature.  They are stored in a list, sorted by
* arity.
*/
final private List<SignatureSymbol> symbols;

/**
* Return a list of sets, where every symbol in the ith set has arity i.
*
* @return  Every symbol with arity i belongs to the ith set.
*     | for each symbol in this
*     |  result.get(symbol.getArity()).contains(symbol)
* @return  The ith set in the list contains only elements of arity i.
*     | for 0 <= i < result.size()
*     |   for each symbol in result.get(i)
*     |    symbol.getArity() == i
*/
public List<Set<SignatureSymbol>> getSymbolsSorted() {
 List<Set<SignatureSymbol>> result = new ArrayList<Set<SignatureSymbol>>();
 for (int i = 0; i <= getMaximalArity(); i++) {
   result.add(i, new HashSet<SignatureSymbol>());
 }
 for (SignatureSymbol symbol : this) {
   result.get(symbol.getArity()).add(symbol);
 }
 // make all sets unmodifiable
 for (int i = 0; i < result.size(); i++) {
   result.set(i, Collections.unmodifiableSet(result.get(i)));
 }
 return result;
 // TODO: improve/remove this for list
}

/**
* Return the maximal arity of an element in this signature.
*/
public int getMaximalArity() {
 return symbols.get(symbols.size()-1).getArity();
}

/**
* Arrange the states in lists, such that every combination of i states is
* in a list in the ith set.

* THIS FUNCTION WORKS FINE (I THINK)

* @param states
*       The states to arrange.
* @return  The ith set represents the ith power of the set of states
*       (cartesian product).  It goes on until getMaximalArity().
*/
public <T extends State> List<Set<List<T>>> arrangeStates(Set<T> states) {
 List<Set<List<T>>> result = new ArrayList<Set<List<T>>>();
 Set<List<T>> setI = new HashSet<List<T>>();
 setI.add(new ArrayList<T>());
 result.add(0, setI);
 for (int i = 1; i <= getMaximalArity(); i++) {
   setI = new HashSet<List<T>>();
   result.add(i, setI);
   for (T state : states) {
     for (List<T> list : result.get(i - 1)) {
       List<T> newList = new ArrayList<T>();
       newList.add(0, state);
       // copy list into newList from position 1
       newList.addAll(1, list);
       setI.add(newList);
     }
   }
 }
 return result;
}

/**
* Sort the given states such that for each symbol of this signature, if its
* arity is i, all possible FunctionInputTuples with combinations of states
* of length i are in the ith set in the resulting list.
*
* @param states
*       The states to sort.
* @return  Every tuple in set i has a symbol of arity i.
*     | for each 0 < i <= result.size()
*     |  for each tuple in result.get(i)
*     |    tuple.getSymbol().getArity() == i
* @return  Every possible combination of i states is in set i for each
*       symbol of arity i.
*     | for each 0 < i <= result.size()
*     |  for each symbol in this
*     |    if (symbol.getArity() == i)
*     |     then for each s_1 ... s_i in states
*     |      result.get(i).contains(
*     |        FunctionInputTuple.getInstance(symbol, s_1, ... s_i)
*/
public List<Set<FunctionInputTuple>> sortForArities(Set<? extends State>
states) {
 List<Set<SignatureSymbol>> sortSyms = getSymbolsSorted();
 List<Set<FunctionInputTuple>> result = new
ArrayList<Set<FunctionInputTuple>>();

// HERE IS THE PROBLEM
 List<Set<List<State>>> arrangedStates = this.arrangeStates(states);

 for (Set<SignatureSymbol> set : sortSyms) {
   Set<FunctionInputTuple> aritySet = new HashSet<FunctionInputTuple>();
   result.add(aritySet); // to the end!
   for (SignatureSymbol symbol : set) {
     for (List<State> stateArr : arrangedStates.get(symbol.getArity())) {
       try {
         aritySet.add(FunctionInputTuple.getInstance(symbol,
             stateArr));
       } catch (FunctionArgumentsMismatchException e) {
         // should not occur
       }
     }
   }
 }
 return result;
}

}

I hope it is readable, if necessary, I can trim down some more.
Thanks for any help, H.