more work on interpolation

src/interp/foci2stub/foci2.cpp

@@ -0,0 +1,25 @@
+/*++
+Copyright (c) 2011 Microsoft Corporation
+
+Module Name:
+
+    foci2.cpp
+
+Abstract:
+
+   Fake foci2, to be replaced
+
+Author:
+
+    Ken McMillan (kenmcmil)
+
+Revision History:
+
+--*/
+
+
+#include "foci2.h"
+
+FOCI2_EXPORT foci2 *foci2::create(const std::string &){
+  return 0;
+}

src/interp/iz3interp.cpp

@@ -233,7 +233,7 @@ void iz3interpolate(scoped_ptr<ast_manager> &_m_manager,
 		    const ptr_vector<ast> &cnsts,
 		    const ::vector<int> &parents,
 		    ptr_vector<ast> &interps,
-		    const ptr_vector<ast> theory,
+		    const ptr_vector<ast> &theory,
 		    interpolation_options_struct * options)
 {
   std::vector<ast_r> _cnsts(cnsts.size());

src/interp/iz3interp.h

@@ -34,7 +34,7 @@ void iz3interpolate(scoped_ptr<ast_manager> &_m_manager,
 		    const ptr_vector<ast> &cnsts,
 		    const ::vector<int> &parents,
 		    ptr_vector<ast> &interps,
-		    const ptr_vector<ast> theory,
+		    const ptr_vector<ast> &theory,
 		    interpolation_options_struct * options = 0);
 
 #endif

src/interp/iz3mgr.cpp

@@ -44,7 +44,54 @@ iz3mgr::ast iz3mgr::make_var(const std::string &name, type ty){
 }
 
 iz3mgr::ast iz3mgr::make(opr op, int n, raw_ast **args){
-  return m().mk_app(m().get_basic_family_id(), op, 0, 0, n, (expr **)args);        
+  switch(op) {
+  case True:     return mki(m_basic_fid,OP_TRUE,n,args);
+  case False:    return mki(m_basic_fid,OP_FALSE,n,args);
+  case Equal:    return mki(m_basic_fid,OP_EQ,n,args);
+  case Distinct: return mki(m_basic_fid,OP_DISTINCT,n,args);
+  case Ite:      return mki(m_basic_fid,OP_ITE,n,args);
+  case And:      return mki(m_basic_fid,OP_AND,n,args);
+  case Or:       return mki(m_basic_fid,OP_OR,n,args);
+  case Iff:      return mki(m_basic_fid,OP_IFF,n,args);
+  case Xor:      return mki(m_basic_fid,OP_XOR,n,args);
+  case Not:      return mki(m_basic_fid,OP_NOT,n,args);
+  case Implies:  return mki(m_basic_fid,OP_IMPLIES,n,args);
+  case Oeq:      return mki(m_basic_fid,OP_OEQ,n,args);
+  case Leq:      return mki(m_arith_fid,OP_LE,n,args);
+  case Geq:      return mki(m_arith_fid,OP_GE,n,args);
+  case Lt:       return mki(m_arith_fid,OP_LT,n,args);
+  case Gt:       return mki(m_arith_fid,OP_GT,n,args);
+  case Plus:     return mki(m_arith_fid,OP_ADD,n,args);
+  case Sub:      return mki(m_arith_fid,OP_SUB,n,args);
+  case Uminus:   return mki(m_arith_fid,OP_UMINUS,n,args);
+  case Times:    return mki(m_arith_fid,OP_MUL,n,args);
+  case Div:      return mki(m_arith_fid,OP_DIV,n,args);
+  case Idiv:     return mki(m_arith_fid,OP_IDIV,n,args);
+  case Rem:      return mki(m_arith_fid,OP_REM,n,args);
+  case Mod:      return mki(m_arith_fid,OP_MOD,n,args);
+  case Power:    return mki(m_arith_fid,OP_POWER,n,args);
+  case ToReal:   return mki(m_arith_fid,OP_TO_REAL,n,args);
+  case ToInt:    return mki(m_arith_fid,OP_TO_INT,n,args);
+  case IsInt:    return mki(m_arith_fid,OP_IS_INT,n,args);
+  case Store:    return mki(m_array_fid,OP_STORE,n,args);
+  case Select:   return mki(m_array_fid,OP_SELECT,n,args);
+  case ConstArray: return mki(m_array_fid,OP_CONST_ARRAY,n,args);
+  case ArrayDefault: return mki(m_array_fid,OP_ARRAY_DEFAULT,n,args);
+  case ArrayMap: return mki(m_array_fid,OP_ARRAY_MAP,n,args);
+  case SetUnion: return mki(m_array_fid,OP_SET_UNION,n,args);
+  case SetIntersect: return mki(m_array_fid,OP_SET_INTERSECT,n,args);
+  case SetDifference: return mki(m_array_fid,OP_SET_DIFFERENCE,n,args);
+  case SetComplement: return mki(m_array_fid,OP_SET_COMPLEMENT,n,args);
+  case SetSubSet: return mki(m_array_fid,OP_SET_SUBSET,n,args);
+  case AsArray:   return mki(m_array_fid,OP_AS_ARRAY,n,args);
+  default:
+    assert(0);
+    return ast();
+  }
+}
+
+iz3mgr::ast iz3mgr::mki(family_id fid, decl_kind dk, int n, raw_ast **args){
+  return m().mk_app(fid, dk, 0, 0, n, (expr **)args);        
 }
 
 iz3mgr::ast iz3mgr::make(opr op, const std::vector<ast> &args){

src/interp/iz3mgr.h

@@ -420,8 +420,8 @@ class iz3mgr  {
   scoped_ptr<ast_manager> m_manager;
 
  private:
+  ast mki(family_id fid, decl_kind sk, int n, raw_ast **args);
   ast make(opr op, int n, raw_ast **args);
-
   ast make(symb sym, int n, raw_ast **args);
 
   family_id                  m_basic_fid;

src/interp/iz3profiling.cpp

@@ -0,0 +1,138 @@
+/*++
+Copyright (c) 2011 Microsoft Corporation
+
+Module Name:
+
+    iz3profiling.h
+
+Abstract:
+
+   Some routines for measuring performance.
+
+Author:
+
+    Ken McMillan (kenmcmil)
+
+Revision History:
+
+--*/
+
+#include "iz3profiling.h"
+
+#include <map>
+#include <iostream>
+#include <string>
+#include <string.h>
+#include <stdlib.h>
+
+
+// FIXME fill in these stubs
+
+#define clock_t int
+
+static clock_t current_time(){
+  return 0;
+}
+
+static void output_time(std::ostream &os, clock_t time){
+  os << ((double)time)/1000;
+}
+
+
+namespace profiling {
+  
+  void show_time(){
+    output_time(std::cout,current_time());
+    std::cout << "\n";
+  }
+
+  typedef std::map<const char*, struct node> nmap;
+  
+  struct node {
+    std::string name;
+    clock_t time;
+    clock_t start_time;
+    nmap sub;
+    struct node *parent;
+    
+    node();
+  } top;
+  
+  node::node(){
+    time =  0;
+    parent = 0;
+  }
+  
+  struct node *current;
+  
+  struct init {
+    init(){
+      top.name = "TOTAL";
+      current = &top;
+    }
+  } initializer;
+  
+  struct time_entry {
+    clock_t t;
+    time_entry(){t = 0;};
+    void add(clock_t incr){t += incr;}
+  };
+  
+  struct ltstr
+  {
+    bool operator()(const char* s1, const char* s2) const
+    {
+      return strcmp(s1, s2) < 0;
+    }
+  };
+  
+  typedef  std::map<const char*, time_entry, ltstr> tmap;
+
+  static std::ostream *pfs;
+
+  void print_node(node &top, int indent, tmap &totals){
+    for(int i = 0; i < indent; i++) (*pfs) << "  ";
+    (*pfs) << top.name;
+    int dots = 70 - 2 * indent - top.name.size();
+    for(int i = 0; i <dots; i++) (*pfs) << ".";
+    output_time(*pfs, top.time);
+    (*pfs) << std::endl;
+    if(indent != 0)totals[top.name.c_str()].add(top.time);
+    for(nmap::iterator it = top.sub.begin(); it != top.sub.end(); it++)
+      print_node(it->second,indent+1,totals);
+  }
+  
+  void print(std::ostream &os) {
+    pfs = &os;
+    top.time = 0;
+    for(nmap::iterator it = top.sub.begin(); it != top.sub.end(); it++)
+      top.time += it->second.time;
+    tmap totals;
+    print_node(top,0,totals);
+    (*pfs) << "TOTALS:" << std::endl;
+    for(tmap::iterator it = totals.begin(); it != totals.end(); it++){
+      (*pfs) << (it->first) << " ";
+      output_time(*pfs, it->second.t);
+      (*pfs) << std::endl;
+    }
+  }
+  
+  void timer_start(const char *name){
+    node &child = current->sub[name];
+    if(child.name.empty()){ // a new node
+      child.parent = current;
+      child.name = name;
+    }
+    child.start_time = current_time();
+    current = &child;
+  }
+
+  void timer_stop(const char *name){
+    if(current->name != name || !current->parent){
+      std::cerr << "imbalanced timer_start and timer_stop";
+      exit(1);
+    }
+    current->time += (current_time() - current->start_time);
+    current = current->parent;
+  }
+}