sc_proj.c File Reference

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "linear_assert.h"
#include <getopt.h>
#include "arithmetique.h"
#include "vecteur.h"
#include "contrainte.h"
#include "sc.h"

Include dependency graph for sc_proj.c:

Go to the source code of this file.

Functions
char *	sc_internal_symbol_table (char *)
int	main (int argc, char *const argv[])

Function Documentation

main()

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

Definition at line 37 of file sc_proj.c.

{
  // option management
  bool reverse = false, bound = false;
  int debug = 0, opt;
  while ((opt = getopt(argc, argv, "bhrD")) != -1) {
    switch (opt) {
    case 'r': reverse = true; break;
    case 'b': bound = true; break;
    case 'D': debug++; break;
    case 'h':
      fprintf(stdout,
              "usage: %s [-r or -b] variables... < system\n"
              "\tdefault: project listed variables\n"
              "\t-r: project all but the listed variables\n"
              "\t-b: show bounds on listed variables\n",
              argv[0]);
      exit(0);
    default: exit(1);
    }
  }
  // only one of -r and -b
  assert(!(reverse && bound));
 
  // get system from stdin
  Psysteme s;
  bool ok = sc_fscan(stdin, &s);
  assert(ok);
  if (debug >= 2) sc_fprint(stderr, s, *variable_default_name);
 
  // get command arguments as a base
  Pbase arg_base = BASE_NULLE;
  for (int i = optind; i < argc; i++)
    arg_base = base_add_variable(arg_base, sc_internal_symbol_table(argv[i]));
 
  Pbase proj_base;
  if (reverse || bound) {
    proj_base = vect_copy(sc_base(s));
    for (Pbase b = arg_base; b != BASE_NULLE; b = vecteur_succ(b))
      proj_base = base_remove_variable(proj_base, vecteur_var(b));
  }
  else {
    proj_base = vect_copy(arg_base);
  }
 
  // project all "proj_base" variables
  for (Pbase b = proj_base; b != BASE_NULLE; b = vecteur_succ(b))
      s = sc_projection(s, vecteur_var(b));
 
  // cleanup
  sc_nredund(&s);
 
  if (debug) sc_fprint(stderr, s, *variable_default_name);
 
  // print out result
  if (bound) {
    // we must bound each remaining variables
    for (Pbase b = arg_base; b != BASE_NULLE; b = vecteur_succ(b)) {
      Variable keep = vecteur_var(b);
      Psysteme sb = sc_copy(s);
      // YES, we use *s* base
      for (Pbase c = sc_base(s); c != BASE_NULLE; c = vecteur_succ(c)) {
        if (vecteur_var(c) != keep)
          sb = sc_projection(sb, vecteur_var(c));
      }
      sc_nredund(&sb);
      sc_fprint(stdout, sb, *variable_default_name);
      sc_rm(sb);
    }
  }
  else
    sc_fprint(stdout, s, *variable_default_name);
 
  base_rm(arg_base);
  base_rm(proj_base);
  sc_rm(s);
  return 0;
}

References assert, base_add_variable(), BASE_NULLE, base_remove_variable(), base_rm, debug(), exit, fprintf(), keep, ok, optind, sc_copy(), sc_fprint(), sc_fscan(), sc_internal_symbol_table(), sc_rm(), variable_default_name(), vect_copy(), vecteur_succ, and vecteur_var.

Here is the call graph for this function:

sc_internal_symbol_table()

char* sc_internal_symbol_table

(

char *

)

Referenced by main().

Here is the caller graph for this function: