/*
*
* $Author: work $
* $Revision: 1.5 $
* $Log: AllASMs.java,v $
* Revision 1.5  2000-03-31 20:14:31-06  work
* toString() now displays count of ASMs for each
* attribute
*
* Revision 1.4  2000-03-31 06:21:30-06  work
* production release version 1
*
* Revision 1.3  2000-03-31 05:52:06-06  work
* this version was accidentally checked-in,
* so please ignore
*
* Revision 1.2  2000-03-31 05:16:04-06  work
* debugged working version
* to do:
* 1) create vector of keys (attributes)
* 2) convert it to an array (that's what we store)
* 3) sort it
*
* - toString()
*
* Revision 1.1  2000-03-29 21:14:18-06  work
* Initial revision
*
*/

/*
* Copyright (C) 2000  
*
*    This program is free software; you can redistribute it and/or modify
*    it under the terms of the GNU General Public License as published by
*    the Free Software Foundation; either version 2 of the License, or
*    (at your option) any later version.
*
*    This program is distributed in the hope that it will be useful,
*    but WITHOUT ANY WARRANTY; without even the implied warranty of
*    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
*    GNU General Public License for more details. 
*
*    You should have received a copy of the GNU General Public License
*    along with this program; if not, write to the Free Software
*    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
*/


import java.util.*;
import java.io.*;

class AllASMs implements Serializable
{
	public final int dimension;
	public final Hashtable ASMattributesToASMvectorHashtable;
	public final ASMattributes[] sortedAttributes;
	public final int count;
	
	private ASM A;
	private int lastNonUnitOfCurrentRow;
	private int[] lastNonUnitOfColumns;
	
	// constructor
	public AllASMs( int dimension )
	{
		this.dimension = dimension;
		
		// the magic number of 67 is the next prime after
		// 47/0.75 where 47 is # of 3x3 ASMs and 0.75 is the
		// default load factor of the hash table
		ASMattributesToASMvectorHashtable = new Hashtable(67);
		
		lastNonUnitOfCurrentRow = 0;
		lastNonUnitOfColumns = new int[dimension];
		for( int i=0; i < dimension; i++ )
			lastNonUnitOfColumns[i] = 0;
		
		A = new ASM( dimension );
		generateASM( 0, 0, 0, 0 );
		
		Vector ASMattributesVector = new Vector();
		Enumeration keysWalk = ASMattributesToASMvectorHashtable.keys();
		while( keysWalk.hasMoreElements() )
			ASMattributesVector.addElement( keysWalk.nextElement() );
		
		sortedAttributes = new ASMattributes[ASMattributesVector.size()];
		ASMattributesVector.copyInto( sortedAttributes );
		new QuickSort( sortedAttributes );
		
		int c = 0;
		for( int i=0; i<sortedAttributes.length; i++ )
			c += ((Vector) ASMattributesToASMvectorHashtable.get(sortedAttributes[i])).size();
		count = c;
	}
	
	private void generateASM( int i, int j, int lastNonUnitOfCurrentRow, int lastNonUnitOfCurrentColumn )
	{
		// System.out.println( i+" "+j+" "+lastNonUnitOfCurrentRow+" "+lastNonUnitOfCurrentColumn+"\n"+A );
		
		if( i == dimension && j == 0 ) {
			A.computeAttributes();
			
			Vector ASMvector = (Vector) ASMattributesToASMvectorHashtable.get( A.attributes );	
			if( ASMvector == null ) {
				ASMvector = new Vector();
				
				// note that our specialized version of ASM.clone()
				// does not copy the attributes field, so
				// (A.clone()).attributes always == A.attributes
				ASMvector.addElement( A.clone() );
				ASMattributesToASMvectorHashtable.put( A.attributes, ASMvector );
				// System.out.println( "finished:\n" + (ASM) ASMvector.firstElement() );
				return;
			}
			
			ASM copyOfA = (ASM) A.clone();
			copyOfA.attributes = ((ASM) ASMvector.firstElement()).attributes;
			ASMvector.addElement( copyOfA );
			// System.out.println( "finished:\n" + copyOfA );
			
			// no need to do put( A.attributes, ASMvector ) since 
			// it's already there in the hashtable 
			return;
		}
		
		int nextI = i, nextJ = j+1;
		if( j == dimension-1 ) {
			nextI++;
			nextJ=0;
		}
		
		// try entry = 1
		if( lastNonUnitOfCurrentRow != 1 && lastNonUnitOfCurrentColumn != 1 ) {
			A.matrix[i][j] = 1;
			lastNonUnitOfColumns[j] = 1;
			// System.out.println( "e: 1" );
			generateASM( nextI, nextJ, nextJ==0?0:1, lastNonUnitOfColumns[nextJ] );
			
			// reset to previous value
			lastNonUnitOfColumns[j] = lastNonUnitOfCurrentColumn;
		}
		
		// try entry = 0
		if( (nextJ != 0 || lastNonUnitOfCurrentRow == 1) 
				&& ((dimension-nextI) != 0 || lastNonUnitOfCurrentColumn == 1) ) {
			A.matrix[i][j] = 0;
			// System.out.println( "e: 0" );
			generateASM( nextI, nextJ, nextJ==0?0:lastNonUnitOfCurrentRow, lastNonUnitOfColumns[nextJ] );
			// no reset since nothing changed
		}
		
		// try entry = -1
		if( lastNonUnitOfCurrentRow == 1 && 
				lastNonUnitOfCurrentColumn == 1 &&
				nextJ != 0 &&
				(dimension-nextI) != 0 ) {
			A.matrix[i][j] = -1;
			lastNonUnitOfColumns[j] = -1;
			// System.out.println( "e: -1" );
			generateASM( nextI, nextJ, nextJ==0?0:-1, lastNonUnitOfColumns[nextJ] );
			
			// reset to previous value
			lastNonUnitOfColumns[j] = lastNonUnitOfCurrentColumn;
		}
		
	}
	
	public String toString()
	{
		String s = "";
		s += "Dimension = "+dimension+"\n";
		s += "Number of distinct (n,k,m,p) attributes = "+sortedAttributes.length+"\n";
		s += "Number of ASMs = "+count+"\n\n";
		
		for( int i=0; i<sortedAttributes.length; i++ ) {
			Vector ASMvector = (Vector) ASMattributesToASMvectorHashtable.get(sortedAttributes[i]);
			
			s += sortedAttributes[i].toString()+" #="+ASMvector.size()+"\n";
			
			Enumeration ASMwalk = ASMvector.elements();
			while( ASMwalk.hasMoreElements() )
				s += ((ASM) ASMwalk.nextElement()).printMatrix()+"\n";
			
			// s += "\n";
		}
		
		return s;
	}
	
	public static void main( String[] args )
	{
		if( args.length < 1 ) {
			System.err.println( "usage: java AllASMs n" );
			System.exit(1);
		}
		
		AllASMs all = new AllASMs( Integer.parseInt(args[0]) );
		System.out.println( all );
		
		// System.out.println( all+"\n"+all.ASMattributesToASMvectorHashtable.size() );
		// System.out.println( all.sortedAttributes.length );
		// for( int i=0; i<all.sortedAttributes.length; i++ )
		// System.out.println( all.sortedAttributes[i] );
	}
}