/* cdd_both_reps.c: compute reduced H and V representation of polytope

   by Volker Braun <vbraun@stp.dias.ie>

   The input is taken from stdin and can be either a 

   H or V representation, not necessarily reduced.

   based on testcdd1.c, redcheck.c, and of course the cdd library

   written by Komei Fukuda, fukuda@ifor.math.ethz.ch

   Standard ftp site: ftp.ifor.math.ethz.ch, Directory: pub/fukuda/cdd

*/

/*  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., 675 Mass Ave, Cambridge, MA 02139, USA.

*/

#include "setoper.h"

#include "cdd.h"

#include <stdio.h>

#include <stdlib.h>

#include <time.h>

#include <math.h>

#include <string.h>

void compute_adjacency(dd_MatrixPtr Rep, dd_ErrorType* err_ptr)

{

  dd_SetFamilyPtr AdjacencyGraph;

  if (*err_ptr != dd_NoError) return;

  switch (Rep->representation) {

  case dd_Inequality: 

    printf("Facet graph\n");

    break;

  case dd_Generator: 

    printf("Vertex graph\n");

    break;

  case dd_Unspecified:

    printf("unknown representation type!\n");

  default:

    printf("This should be unreachable!\n");

    exit(2);

  }

  /* Output adjacency of vertices/rays/lines */

  if (Rep->rowsize > 0) {  /* workaround for bug with empty polyhedron */

    /* compute adjacent vertices/rays/lines */

    AdjacencyGraph = dd_Matrix2Adjacency(Rep, err_ptr);

    if (*err_ptr == dd_NoError) {

      dd_WriteSetFamily(stdout,AdjacencyGraph);

      dd_FreeSetFamily(AdjacencyGraph);

    }

  } else {

    printf("begin\n");

    printf("  0    0\n");

    printf("end\n");

  }

  printf("\n");

}

void minimal_Vrep_Hrep(dd_MatrixPtr M, 

		       dd_MatrixPtr* Vrep_ptr, dd_MatrixPtr* Hrep_ptr, 

		       dd_ErrorType* err_ptr)

{

  dd_PolyhedraPtr poly;

  dd_rowindex newpos;

  dd_rowset impl_linset,redset;

  dd_MatrixPtr Vrep, Hrep;

  if (*err_ptr != dd_NoError) return;

   /* compute the second representation */

  poly = dd_DDMatrix2Poly(M, err_ptr);

  if (*err_ptr != dd_NoError) return;

  if (*err_ptr == dd_NoError) {

    /* compute canonical H-representation */

    Hrep = dd_CopyInequalities(poly);

    if (Hrep->rowsize > 0) {  /* workaround for bug with empty matrix */

      dd_MatrixCanonicalize(&Hrep, &impl_linset, &redset, &newpos, err_ptr);

      if (*err_ptr == dd_NoError) {

	set_free(redset);

	set_free(impl_linset);

	free(newpos);

      }

    }

    if (*err_ptr == dd_NoError) (*Hrep_ptr) = Hrep;

  }

  if (*err_ptr == dd_NoError) {

    /* compute canonical V-representation */

    Vrep = dd_CopyGenerators(poly);

    if (Vrep->rowsize > 0) {  /* workaround for bug with empty matrix */

      dd_MatrixCanonicalize(&Vrep, &impl_linset, &redset, &newpos, err_ptr);

      if (*err_ptr == dd_NoError) {

	set_free(redset);

	set_free(impl_linset);

	free(newpos);

      }

    }

    if (*err_ptr == dd_NoError) (*Vrep_ptr) = Vrep;

  }

  dd_FreePolyhedra(poly);

}

void print_both_reps(dd_MatrixPtr Vrep, dd_MatrixPtr Hrep)

{

  /* Output V-representation */

  dd_WriteMatrix(stdout,Vrep);

  printf("\n");

  /* Output H-representation */

  dd_WriteMatrix(stdout,Hrep);

  printf("\n");

}

void compute_both_reps(dd_MatrixPtr M, dd_ErrorType* err_ptr)

{

  dd_MatrixPtr Vrep, Hrep;

  minimal_Vrep_Hrep(M, &Vrep, &Hrep, err_ptr);

  if (*err_ptr != dd_NoError) return;

  print_both_reps(Vrep, Hrep);

  dd_FreeMatrix(Hrep);

  dd_FreeMatrix(Vrep);

}

void compute_all(dd_MatrixPtr M, dd_ErrorType* err_ptr)

{

  dd_MatrixPtr Vrep, Hrep;

  minimal_Vrep_Hrep(M, &Vrep, &Hrep, err_ptr);

  if (*err_ptr != dd_NoError) return;

  print_both_reps(Vrep, Hrep);

  compute_adjacency(Vrep, err_ptr);

  compute_adjacency(Hrep, err_ptr);

  dd_FreeMatrix(Hrep);

  dd_FreeMatrix(Vrep);

}

void usage(char *name)

{

  printf("No known option specified, I don't know what to do!\n"

	 "Usage:\n"

	 "%s --option\n"

	 "where --option is precisely one of the following:\n\n"

	 "  --all: Compute everything.\n"

	 "    This will compute minimal H-,V-representation and vertex and facet graph.\n"

	 "\n"

	 "  --reps: Compute both a minimal H- and minimal V-representation.\n"

	 "\n"

	 "  --adjacency: Compute adjacency information only.\n"

	 "    The input is assumed to be a minimal representation, as, for example, computed\n"

	 "    by --reps. Warning, you will not get the correct answer if the input\n"

	 "    representation is not minimal! The output is the vertex or facet graph,\n"

	 "    depending on the input.\n"

	 "\n"

	 "The input data is a H- or V-representation in cdd's ine/ext format and\n"

	 "is in each case read from stdin.\n", 

	 name);

}

enum command_line_arguments { ALL, REPS, ADJACENCY };

int parse_arguments(char* arg, enum command_line_arguments* option)

{

  if (strcmp(arg,"--all")==0) {

    *option = ALL;

    return 0;

  }

  if (strcmp(arg,"--reps")==0) {

    *option = REPS;

    return 0;

  }

  if (strcmp(arg,"--adjacency")==0) {

    *option = ADJACENCY;

    return 0;

  }

  printf("Unknown option: %s\n", arg);

  return 1;

}

int main(int argc, char *argv[])

{

  dd_ErrorType err=dd_NoError;

  dd_MatrixPtr M;

  enum command_line_arguments option;

  if (argc!=2 || parse_arguments(argv[1],&option)) {

    usage(argv[0]);

    return 0;

  } 

  dd_set_global_constants(); 

  /* Read data from stdin */

  M = dd_PolyFile2Matrix(stdin, &err;;

  if (err != dd_NoError) {

    printf("I was unable to parse the input data!\n");

    dd_WriteErrorMessages(stdout,err);

    dd_free_global_constants();

    return 1;

  }

  switch (option) {

  case ALL:

    compute_all(M,&err;;

    break;

  case REPS:

    compute_both_reps(M,&err;;

    break;

  case ADJACENCY:

    compute_adjacency(M,&err;;

    break;

  default:

    printf("unreachable option %d\n", option);

    exit(3); /* unreachable */

  }

  /* cleanup */

  dd_FreeMatrix(M);

  if (err != dd_NoError) {

    dd_WriteErrorMessages(stdout,err);

  }

  dd_free_global_constants();

  return 0;

}