CompressedPayoffMatrix.java

/*
 * JASA Java Auction Simulator API
 * Copyright (C) 2013 Steve Phelps
 *
 * 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.
 */

package net.sourceforge.jabm.gametheory;

import java.io.FileInputStream;
import java.io.ObjectInputStream;
import java.io.PrintWriter;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;

import net.sourceforge.jabm.report.AggregatePayoffMap;
import net.sourceforge.jabm.report.DataWriter;
import net.sourceforge.jabm.report.PayoffMap;
import net.sourceforge.jabm.strategy.Strategy;
import net.sourceforge.jabm.util.BaseNIterator;
import net.sourceforge.jabm.util.MathUtil;
import net.sourceforge.jabm.util.Partitioner;

import org.apache.commons.math3.stat.descriptive.StatisticalSummary;
import org.apache.commons.math3.stat.descriptive.SummaryStatistics;
import org.apache.log4j.Logger;

import cern.jet.math.Arithmetic;

/**
 * @author Steve Phelps
 * @version $Revision: 325 $
 */

public class CompressedPayoffMatrix  implements Serializable {
	
	protected HashMap<Entry,PayoffMap> matrix;

	protected int numRoles;

	protected int numStrategiesPerRole[];

	protected int numPlayersPerRole[];

	protected int numPlayers;

	protected int numStrategies;

	protected int numEntries;

	static Logger logger = Logger.getLogger(CompressedPayoffMatrix.class);

	public CompressedPayoffMatrix(int numRoles, int[] numStrategiesPerRole,
	    int[] numPlayersPerRole, List<Strategy> strategies) {
		numEntries = 0;
		this.numRoles = numRoles;
		this.numPlayersPerRole = numPlayersPerRole;
		this.numStrategiesPerRole = numStrategiesPerRole;
		for (int i = 0; i < numRoles; i++) {
			numPlayers += numPlayersPerRole[i];
			numStrategies += numStrategiesPerRole[i];
		}
		matrix = new HashMap<Entry,PayoffMap>();
		OrderedEntryIterator i = new OrderedEntryIterator();
		while (i.hasNext()) {
			Entry e = i.next();
			matrix.put(e, new AggregatePayoffMap(strategies));
		}
	}

	public CompressedPayoffMatrix(List<Strategy> strategies, int numPlayers) {
		this(1, new int[] { strategies.size() }, new int[] { numPlayers },
				strategies);
	}
	
	public int size() {
		return matrix.keySet().size();
	}

	public PayoffMap getCompressedPayoffs(Entry entry) {
		return matrix.get(entry);
	}

//	public void updateWithPayoffs(Entry entry, PayoffMap compressedPayoffs) {
//        //TODO
//	}
//
//	public void reset() {
//		Iterator<Entry> i = compressedEntryIterator();
//		while (i.hasNext()) {
//			Entry e = i.next();
//			PayoffMap p = getCompressedPayoffs(e);
//			p.reset();
//		}
//	}

	public Iterator<Entry> compressedEntryIterator() {
		return matrix.keySet().iterator();
	}

	public Iterator<Entry> orderedEntryIterator() {
		return new OrderedEntryIterator();
	}

	public Iterator<FullEntry> fullEntryIterator() {
		final CompressedPayoffMatrix matrix = this;
		return new Iterator<FullEntry>() {

			BaseNIterator b = new BaseNIterator(numStrategies, numPlayers);

			public boolean hasNext() {
				return b.hasNext();
			}

			public FullEntry next() {
				return new FullEntry(b.next(), matrix);
			}

			public void remove() {
			}

		};
	}

	public double[] getFullPayoffs(FullEntry entry) {
		Entry compressedEntry = entry.compress();
		PayoffMap p = getCompressedPayoffs(compressedEntry);
		double[] fullPayoffs = new double[numPlayers];
		for (int i = 0; i < numPlayers; i++) {
			fullPayoffs[i] = p.getMeanPayoff(entry.getStrategy(i));
		}
		return fullPayoffs;
	}

	public double payoff(double[] mixedStrategy) {
		double payoff = 0;
		for (int s = 0; s < mixedStrategy.length; s++) {
			payoff += mixedStrategy[s] * payoff(s, mixedStrategy);
		}
		return payoff;
	}

	public double payoff(int strategy, double[] mixedStrategy) {
		
		if (mixedStrategy[strategy] == 0) {
			return 0;
		}
		
		assert MathUtil.approxEqual(MathUtil.sum(mixedStrategy), 1, 1E-10);
		
		@SuppressWarnings("all")
		double totalProbability = 0;
		double payoff = 0;
		
		Iterator<Entry> entries = compressedEntryIterator();
		iterating: while (entries.hasNext()) {
			Entry entry = entries.next();
			// double[] payoffs = getCompressedPayoffs(entry).getPayoffs();
			PayoffMap p = getCompressedPayoffs(entry);

			if (entry.getNumAgents(strategy) == 0) {
				continue iterating;
			}

			entry = entry.removeSingleAgent(strategy);

			double probability = 1;
			for (int s = 0; s < numStrategies; s++) {
				probability *= Math.pow(mixedStrategy[s], entry.getNumAgents(s));
			}
			probability *= entry.permutations();
			assert probability <= 1 && probability >= 0;
			totalProbability += probability;

			double expectedPayoffToStrategy = p.getMeanPayoff(strategy);
			if (Double.isNaN(expectedPayoffToStrategy)) {
				expectedPayoffToStrategy = 0;
			}
			payoff += probability * expectedPayoffToStrategy;

		}

		return payoff;
	}
	
	public static CompressedPayoffMatrix readFromFile(String fileName) {
		CompressedPayoffMatrix result = null;
		try {
			ObjectInputStream ois;
			ois = new ObjectInputStream(new FileInputStream(fileName));
			result = (CompressedPayoffMatrix) ois.readObject();
		} catch (Exception e) {
			throw new RuntimeException(e);
		}
		return result;
	}
	
	public void export(DataWriter out) {
		Iterator<Entry> entries = orderedEntryIterator();
		while (entries.hasNext()) {
			Entry entry = entries.next();
			for (int s = 0; s < numStrategies; s++) {
				out.newData(entry.getNumAgents(s));
			}
			PayoffMap payoffs = getCompressedPayoffs(entry);
			for (int i = 0; i < payoffs.size(); i++) {
				StatisticalSummary payoffStats = payoffs
						.getPayoffDistribution(i);
				out.newData(payoffStats.getMean());
				out.newData(payoffStats.getStandardDeviation());
				out.newData(payoffStats.getN());
			}
		}
	}

	public void exportToGambit(PrintWriter nfgOut) {
		exportToGambit(nfgOut, "JASA NFG");
	}

	public void exportToGambit(PrintWriter nfgOut, String title) {
		nfgOut.print("NFG 1 R \"" + title + "\" { ");
		for (int i = 0; i < numPlayers; i++) {
			nfgOut.print("\"Player" + (i + 1) + "\" ");
		}
		nfgOut.println("}");
		nfgOut.println();

		nfgOut.print("{ ");
		for (int i = 0; i < numPlayers; i++) {
			nfgOut.print("{ ");
			for (int j = 0; j < numStrategies; j++) {
				nfgOut.print("\"Strategy" + j + "\" ");
			}
			nfgOut.println("}");
		}
		nfgOut.println("}");

		nfgOut.println("\"\"");
		nfgOut.println();

		nfgOut.println("{");
		int numEntries = 0;
		Iterator<FullEntry> entries = fullEntryIterator();
		while (entries.hasNext()) {
			nfgOut.print("{ \"");
			FullEntry fullEntry = entries.next();
			for (int i = numPlayers - 1; i >= 0; i--) {
				nfgOut.print(fullEntry.getStrategy(i) + 1);
			}
			nfgOut.print("\" ");
			double[] outcome = getFullPayoffs(fullEntry);
			for (int i = 0; i < outcome.length; i++) {
				double payoff = outcome[i];
				if (Double.isNaN(payoff)) {
					nfgOut.print("0");
				} else {
					nfgOut.print(payoff);
				}
				if (i < outcome.length - 1) {
					nfgOut.print(",");
				}
				nfgOut.print(" ");
			}
			nfgOut.println("}");
			numEntries++;
		}
		nfgOut.println("}");
		for (int i = 1; i <= numEntries; i++) {
			nfgOut.print(i);
			if (i < numEntries) {
				nfgOut.print(" ");
			}
		}
		nfgOut.flush();
	}

	public int getNumStrategies() {
		return numStrategies;
	}

	public int getNumPlayers() {
		return numPlayers;
	}

	public int getNumPlayersPerRole(int role) {
		return numPlayersPerRole[role];
	}

	public int getNumStrategiesPerRole(int role) {
		return numStrategiesPerRole[role];
	}

	public int getNumEntries() {
		return numEntries;
	}
	

	class OrderedEntryIterator implements Iterator<Entry>, Serializable {

		private Partitioner[] p;

		ArrayList<int[]> state;

		public OrderedEntryIterator() {
			p = new Partitioner[numRoles];
			state = new ArrayList<int[]>(numRoles);
			for (int i = 0; i < numRoles; i++) {
				p[i] = new Partitioner(numPlayersPerRole[i], numStrategiesPerRole[i]);
				state.add(i, null);
			}
		}

		public boolean hasNext() {
			for (int i = 0; i < numRoles; i++) {
				if (p[i].hasNext()) {
					return true;
				}
			}
			return false;
		}

		public Entry next() {
			for (int i = 0; i < numRoles - 1; i++) {
				if (state.get(i) == null) {
					state.set(i, p[i].next());
				}
			}
			nextState(numRoles - 1);
			int[] entry = new int[numStrategies];
			int strategy = 0;
			for (int i = 0; i < numRoles; i++) {
				for (int s = 0; s < numStrategiesPerRole[i]; s++) {
					entry[strategy++] = state.get(i)[s];
				}
			}
			return new Entry(entry);
		}

		public void remove() {
		}

		protected void nextState(int role) {
			if (p[role].hasNext()) {
				state.set(role, p[role].next());
			} else {
				p[role] = new Partitioner(numPlayersPerRole[role],
				    numStrategiesPerRole[role]);
				state.set(role, p[role].next());
				if (role > 0) {
					nextState(role - 1);
				}
			}
		}

	}

	public static class Entry implements Cloneable, Serializable {

		protected int[] numAgentsPerStrategy;

		public Entry(int[] numAgentsPerStrategy) {
			this.numAgentsPerStrategy = numAgentsPerStrategy;
		}

		public int getNumAgents(int strategy) {
			return numAgentsPerStrategy[strategy];
		}

		public Object clone() throws CloneNotSupportedException {
			Entry newEntry = (Entry) super.clone();
			newEntry.numAgentsPerStrategy = this.numAgentsPerStrategy.clone();
			return newEntry;
		}

		public Entry removeSingleAgent(int strategy) {
			try {
				Entry entry = (Entry) clone();
				if (numAgentsPerStrategy[strategy] > 0) {
					entry.numAgentsPerStrategy[strategy]--;
				}
				return entry;
			} catch (CloneNotSupportedException e) {
				throw new RuntimeException(e);
			}
		}

		public String toString() {
			StringBuilder result = new StringBuilder("");
			int numStrategies = numAgentsPerStrategy.length;
			for (int i = 0; i < numStrategies - 1; i++) {
				result.append(numAgentsPerStrategy[i]).append("/");
			}
			result.append(numAgentsPerStrategy[numStrategies - 1]);
			return result.toString();
		}

		public long permutations() {
			int numAgents = 0;
			for (int i = 0; i < numAgentsPerStrategy.length; i++) {
				numAgents += numAgentsPerStrategy[i];
			}
			long r = 1;
			for (int i = 0; i < numAgentsPerStrategy.length; i++) {
				r *= Arithmetic.factorial(numAgentsPerStrategy[i]);
			}
			return ((long) Arithmetic.factorial(numAgents)) / r;
		}

		public boolean equals(Object other) {
			for (int i = 0; i < numAgentsPerStrategy.length; i++) {
				if (this.numAgentsPerStrategy[i] != ((Entry) other).numAgentsPerStrategy[i]) {
					return false;
				}
			}
			return true;
		}

		public int hashCode() {
			int radix = 0;
			for (int i = 0; i < numAgentsPerStrategy.length; i++) {
				radix += numAgentsPerStrategy[i];
			}
			int hash = 0;
			int base = 1;
			for (int i = 0; i < numAgentsPerStrategy.length; i++) {
				hash += numAgentsPerStrategy[i] * base;
				base *= radix;
			}
			return hash;
		}
	}

	public static class FullEntry implements Serializable {

		protected int[] pureStrategyProfile;

		protected CompressedPayoffMatrix matrix;

		public FullEntry(int[] pureStrategyProfile, CompressedPayoffMatrix matrix) {
			this.pureStrategyProfile = pureStrategyProfile;
			this.matrix = matrix;
		}

		public int getStrategy(int player) {
			return pureStrategyProfile[player];
		}

		public Entry compress() {
			int[] numAgentsPerStrategy = new int[matrix.getNumStrategies()];
			for (int i = 0; i < matrix.getNumPlayers(); i++) {
				numAgentsPerStrategy[getStrategy(i)]++;
			}
			return new Entry(numAgentsPerStrategy);
		}

	}

}