// #include <Rcpp.h>
// using namespace Rcpp;
//
//
//
//
// // Computes the pure strategy Nash Equilibria in a 2-player finite game.
// // ---------------------------------------------------------------------
// // input:
// //
// // NS(i) : total number of pure strategies of player (i)
// //
// // Poff : list of two matrices of dimension (NS[1],NS[2])
// // Poff(i,is1,is2) : payoff matrix of player (i) when
// // player (1) plays is1 and player (2) plays is2
// //
// // output : NE
// // NE(1:2,j) is the Nash equilibrium number j
// //
// // ---------------------------------------------------------------------
// // A. Habbal Inria 2016-05
// // V. Picheny INRA 2016-06
// // M. Binois Chicago Booth 2016-06
// // [[Rcpp::export]]
// IntegerVector PSNE_Rcpp(NumericVector NS, NumericMatrix Poff1, NumericMatrix Poff2){
// IntegerMatrix iB1(NS(0), NS(1));
// IntegerMatrix iB2(NS(0), NS(1));
// std::vector<int> NE;
// double B1, B2;
//
// // Set of best replies of player 2 to moves by player 1
// for(int is1 = 0; is1 < NS(0); is1++ ){
// B2 = min(Poff2(is1,_));
// for(int is2 = 0; is2 < NS(1); is2++){
// if(Poff2(is1, is2) == B2){
// iB1(is1, is2) = 1;
// }
// }
// }
//
// // for (is1 in 1:NS[1]){
// // B2 <- min(Poff[[2]][is1,1:NS[2]])
// // for (is2 in 1:NS[2]) {
// // if( Poff[[2]][is1,is2]==B2 ){
// // iB1[is1,is2] <- 1
// // }
// // }
// // }
//
// // Set of best replies of player 1 to moves by player 2
// for(int is2 = 0; is2 < NS(1); is2++){
// B1 = min(Poff1(_, is2));
// for(int is1 = 0; is1 < NS(0); is1++){
// if(Poff1(is1, is2) == B1){
// iB2(is1, is2) = 1;
// }
// }
// }
//
// // for (is2 in 1:NS[2]){
// // B1 <- min(Poff[[1]][1:NS[1],is2])
// // for (is1 in 1:NS[1]) {
// // if(Poff[[1]][is1,is2]==B1) {
// // iB2[is1,is2] <- 1
// // }
// // }
// // }
//
// // Enumerate pure strategy Nash equilibria
// // NE <- c()
// for(int is1 = 0; is1 < NS(0); is1++){
// for(int is2 = 0; is2 < NS(1); is2++){
// if(iB1(is1, is2) + iB2(is1, is2) == 2){
// NE.push_back(is1+1);
// NE.push_back(is2+1);
// }
// }
// }
//
// // for (is1 in 1:NS[1]){
// // for (is2 in 1:NS[2]) {
// // if (iB1[is1,is2]+iB2[is1,is2] == 2) {
// // NE <- rbind(NE, c(is1, is2))
// // }
// // }
// // }
//
// return(as<IntegerVector>(wrap(NE)));
//
// }
//
//
// // You can include R code blocks in C++ files processed with sourceCpp
// // (useful for testing and development). The R code will be automatically
// // run after the compilation.
// //
//
// /*** R
// library(microbenchmark)
//
// ## To have the same entries and outputs than PSNE/PSNE2
// PSNE3 <- function(NS, Poff){
// tmp <- PSNE_Rcpp(NS, Poff[[1]], Poff[[2]])
// if(length(tmp) == 0)
// return(NULL)
// return(matrix(tmp, length(tmp)/2, byrow = T))
// }
//
// Z <- matrix(response.grid, ncol=nobj)
// Z1 <- matrix(Z[,1], n.grid, n.grid)
// Z2 <- matrix(Z[,2], n.grid, n.grid)
// Poff <- list(Z1, Z2)
//
//
// microbenchmark(PSNE(NS=rep(n.grid, 2), Poff = Poff),
// PSNE2(NS=rep(n.grid, 2), Poff = Poff),
// PSNE3(rep(n.grid, 2), Poff = Poff))
//
// */