Changeset 468

Timestamp:

09/07/09 17:04:29 (15 years ago)

Author:

bhilburn

Message:

Fully implemented the CBR as a C++ class, and using it within the CBR_CE
component.

Location:

vtcross/trunk/src

Files:

• cognitive_engines/CBR_CE/CognitiveEngine.cpp (modified) (7 diffs)
• cognitive_engines/CBR_CE/Makefile.am (modified) (1 diff)
• cognitive_engines/CBR_CE/cbr.c (deleted)
• include/vtcross/cbr.h (modified) (1 diff)

vtcross/trunk/src/cognitive_engines/CBR_CE/CognitiveEngine.cpp

@@ -18 +18 @@
 #include <cstring>
 #include <stdint.h>
-#include <math.h>
-
+#include <cmath>
+
+#include "vtcross/cbr.h"
 #include "vtcross/cognitive_engine.h"
 #include "vtcross/common.h"
@@ -26 +27 @@
 #include "vtcross/error.h"
 #include "vtcross/socketcomm.h"
-#include "vtcross/cbr.h"
-
-// TODO this is really bad; need to move to a proper cbr.h
-#include "cbr.c"
-
-#include "sqlite3.h"
-#include "sqlite3ext.h"
-
-
-static cbr myCBR;
-
+
+static CBR *myCBR;
 
 CognitiveEngine::CognitiveEngine()
@@ -48 +40 @@
 CognitiveEngine::~CognitiveEngine()
 {
-    cbr_free(myCBR);
+    delete myCBR;
+
     delete [] pList;
     delete [] oList;
@@ -160 +153 @@
     }
 
-    cbr_update(myCBR, nameList, obsList, valList, obsVals, 
+    myCBR->Update(nameList, obsList, valList, obsVals, 
             numberColumns, obsColumns);
 }
@@ -670 +663 @@
          * If the goal is to minimize, set the search operation to
          * return values less than the target.
+         *
+         * NOTE: the values '2' and '4' here are from some old preprocesser
+         * definitions, which I will copy here until I can figure out just what
+         * exactly they were for:
+                42      #define EQ 0    // equals
+                43      #define NE 1    // not equals
+                44      #define GT 2    // greater than
+                45      #define GE 3    // greater than or equal to
+                46      #define LT 4    // less than
+                47      #define LE 5    // less than or equal to
          */
         if(strcmp(uList[i].goal.c_str(), "max") == 0) {
-            searchOps[i] = GT;
+            searchOps[i] = 2;
         } else if(strcmp(uList[i].goal.c_str(), "min") == 0) {
-            searchOps[i] = LT;
+            searchOps[i] = 4;
         }
     }
 
     /* CBR specific call */
-    uint32_t rc = cbr_search(myCBR, searchNames, searchOps, searchVals,
+    uint32_t rc = myCBR->Search(searchNames, searchOps, searchVals,
             radioInfo->numUtilities, returnValues);
 
@@ -739 +742 @@
 
     // Add row to CBR. 
-    cbr_add_row(myCBR, allNames, returnValues, returnValueIndex+1);
+    myCBR->AddRow(allNames, returnValues, returnValueIndex+1);
 
     return pList;
@@ -791 +794 @@
     cols[columnIndex] = (char *) "utility";
 
-    myCBR = cbr_create(filename, tablename, cols, numberColumns);
-}
-
+    myCBR = new CBR(filename, tablename, cols, numberColumns);
+}
+

vtcross/trunk/src/cognitive_engines/CBR_CE/Makefile.am

@@ -20 +20 @@
 
 bin_PROGRAMS = cbr_demo
-include_HEADERS = cbr.c
 
 cbr_demo_SOURCES = CognitiveEngine.cpp cbr_demo.cpp

vtcross/trunk/src/include/vtcross/cbr.h

@@ -15 +15 @@
 */
 
-//
-// Case-based reasoner
-//
-//
-// TODO REDO THIS FILE
+/* This file contains the declaration *and* default implementation of a VTCROSS
+ * case-based reasoner.
+ *
+ * This class can be used either as-is, or with re-implementations of some/all
+ * of the functions.  All functions are declared virtual, and so may be
+ * overridden in the cognitive engine source file as necessary. In addition,
+ * internal class members are declared 'protected', so that they may be
+ * inherited by child implementations.
+ */
+
 
 #ifndef CBR_H
 #define CBR_H
 
-#include "sqlite3.h"
-//#define CBR_LEN_FILENAME 64
-
-#define DATABASENAME "cactus_cbr"
-
-typedef struct cbr_s * cbr;
-
-// create the CBR
-cbr cbr_create(char * _filename, char * _tablename, char * _cols[], unsigned int _len);
-
-// free the CBR
-void cbr_free(cbr _cbr);
-
-// print databse/table
-void cbr_print(cbr _cbr);
-
-#define EQ 0    // equals
-#define NE 1    // not equals
-#define GT 2    // greater than
-#define GE 3    // greater than or equal to
-#define LT 4    // less than
-#define LE 5    // less than or equal to
-int cbr_search(cbr _cbr, char *_names[], int * _ops, float *_vals, unsigned int _n, float *_retvals);
-
-int cbr_add_row(cbr _cbr, char *_cols[], float *_vals, unsigned int _len);
+#include <cstdlib>
+#include <cstring>
+#include <cstdio>
+#include <stdint.h>
+#include <string>
+#include <sqlite3.h>
+
+#include "vtcross/common.h"
+#include "vtcross/debug.h"
+#include "vtcross/error.h"
+
+using namespace std;
+
+
+#define DATABASENAME "vtcross_cbr"
+
+
+class CBR
+{
+    public:
+        /* Default constructor and preferred constructor for the CBR class. */
+        CBR();
+        CBR(char *_filename, char *_tablename, char *_cols[], uint32_t _len);
+
+        /* Destructor for the CBR class. Note that this destructor will be
+         * called automatically by any derived classes, and so child classes
+         * should not repeat the freeing actions performed in this function. */
+        virtual ~CBR();
+
+        virtual int32_t OpenDatabase();
+
+        virtual int32_t ExecuteCommand();
+
+        virtual int32_t ExecuteSearchCommand(float *_retvals);
+
+        virtual void Print();
+
+        virtual int32_t Search(char *_names[], int32_t *_ops, float *_vals, \
+                uint32_t _n, float *_retvals);
+
+        virtual int32_t Update(char *_where[], char *_set[], float *_wherevals, \
+                float *_setvals, uint32_t _wherelen, uint32_t _setlen);
+
+        virtual int32_t AddRow(char *_cols[], float *_vals, uint32_t _len);
+
+    protected:
+        char filename[64];
+        char tablename[64];
+        char command[2048];
+        sqlite3 *db; 
+        uint32_t numColumns;
+};
+
+
+int32_t 
+callback(void *notUsed, int argc, char **argv, char **azColName)
+{
+    int i;
+    for(i=0; i<argc; i++){
+        printf("%s = %s\n", azColName[i], argv[i] ? argv[i] : "NULL");
+    }
+    printf("\n");
+    return 0;
+}
+
+
+// open a database or create a database if it does not exist
+int32_t 
+CBR::OpenDatabase()
+{
+    int32_t rc;
+
+    rc = sqlite3_open(filename, &db);
+    if(rc) {
+        WARNING("Can't open database: %s\n", sqlite3_errmsg(db));
+        sqlite3_close(db);
+        exit(1);
+    }
+
+    return rc;
+}
+
+
+// execute command
+int32_t
+CBR::ExecuteCommand()
+{
+    int rc;
+    char *zErrMsg = 0;
+
+    rc = sqlite3_exec(db, command, callback, 0, &zErrMsg);
+    if( rc!=SQLITE_OK){
+        fprintf(stderr, "SQL error: %s: %s\n", zErrMsg, command);
+        sqlite3_free(zErrMsg);
+    }
+
+    return rc;
+}
+
+
+// execute search command
+int32_t 
+CBR::ExecuteSearchCommand(float *_retvals)
+{
+    int rc;
+    unsigned int i;
+
+    sqlite3_stmt * pStatement;
+    rc = sqlite3_prepare_v2(db, command, -1, &pStatement, NULL);
+    if (rc == SQLITE_OK){ 
+        if (sqlite3_step(pStatement) == SQLITE_ROW){
+            for (i=0; i<numColumns; ++i)
+                _retvals[i] = sqlite3_column_double(pStatement, i);
+        } else {
+                    printf("CBR:: No matched results returning default.\n");
+                        rc=31337;
+                }
+    } else {
+                printf("CBR:: Error executing SQL statement. rc = %i\n%s\n",rc,command);
+    }
+
+    sqlite3_finalize(pStatement);
+   
+    return rc;
+}
+
+
+// create database
+CBR::CBR(char * _filename, char * _tablename, char * _cols[], unsigned int _len)
+{
+    // create database
+
+    // copy filename
+    unsigned int i=0;
+    strcpy(filename, _filename);
+
+    // execute create database command
+    // database handle
+    //_cbr->db = NULL;
+    OpenDatabase();
+
+    // create table
+
+    // copy tablename
+    strcpy(tablename, _tablename);
+
+    // number of columns in the table
+    numColumns = _len;
+
+    // generate command
+    strcpy(command, "CREATE TABLE ");
+    strcat(command, tablename);
+    strcat(command, "(");
+    for (i=0; i<numColumns; i++) {
+        strcat(command, _cols[i]);
+        strcat(command, " FLOAT");
+        if (i != numColumns-1) // not last entry
+            strcat(command, ", ");
+    }
+    strcat(command, ");");
+
+    // execute create table command
+    ExecuteCommand();
+}
+
+
+// free space
+CBR::~CBR()
+{  
+    // generate command, remove a table with its content
+    strcpy(command, "drop table ");
+    strcat(command, tablename);
+
+    // execute delete command
+    ExecuteCommand();
+
+    // clean the database
+    strcpy(command, "vacuum");
+    ExecuteCommand();
+}
+
+
+// print 
+void 
+CBR::Print()
+{
+    // generate commandi
+    strcpy(command, "select ");
+    strcat(command, tablename);
+    strcat(command, ".* from ");
+    strcat(command, tablename);
+    strcat(command, ";");
+
+    // execute print (select all)  command
+    ExecuteCommand();
+    printf("database %s, table %s:\n", filename, tablename);
+}
+
+//
+// cbr search
+//int cbr_search(cbr _cbr, char *_names[], int * _ops, float *_vals, unsigned int _n, float *_retvals);
+int32_t 
+CBR::Search(
+    char *_names[],
+    int * _ops,
+    float *_vals,
+    unsigned int _n,
+    float *_retvals)
+{   
+    int rc;
+        const char *ops_str[] = {"==", "!=", ">", ">=", "<", "<="};
+    // generate command
+    strcpy(command, "select ");
+    strcat(command, tablename);
+    strcat(command, ".* from ");
+    strcat(command, tablename);
+    strcat(command, " where ");
+
+    unsigned int i;
+    char str_buffer[64];
+    printf("number of ops %d:\n", _n);
+    for (i=0; i<_n; i++) {
+        // ensure valid ops value
+        if (_ops[i] < 0 || _ops[i] > 5) {
+            printf("error: cbr_search(), invalid ops id : %d\n", _ops[i]);
+            exit(1);
+        }
+
+        strcat(command, _names[i]);
+        strcat(command, ops_str[_ops[i]]);
+    printf("search command: %s\n", command);
+        sprintf(str_buffer, "%E", _vals[i]);
+        strcat(command, str_buffer);
+
+
+        if (i<_n-1)
+            strcat(command, " AND ");
+        else
+            strcat(command, " order by utility desc;");
+    }
+
+
+    rc = ExecuteSearchCommand(_retvals);
+    
+    return rc;
+}
+
+
+// update a row 
+int32_t 
+CBR::Update(char *_where[], char*_set[], float *_wherevals, float *_setvals, 
+                unsigned int _wherelen, unsigned int _setlen)
+{
+    unsigned int i;
+    
+    // generate command
+    strcpy(command, "UPDATE ");
+    strcat(command, tablename);
+    
+    strcat(command, " SET ");
+    for (i=0; i<_setlen; i++) {
+        strcat(command, _set[i]);
+        strcat(command, " = ");
+        sprintf(command, "%s%f", command, _setvals[i]);
+        strcat(command, "  ");
+        if (i != _setlen-1) // not last entry
+            strcat(command, ", ");
+    }
+    strcat(command, " WHERE ");
+
+    for (i=0; i<_wherelen; i++) {
+        strcat(command, _where[i]);
+        strcat(command, " = ");
+        sprintf(command, "%s%f", command, _wherevals[i]);
+        strcat(command, "  ");
+        if (i != _wherelen-1) // not last entry
+            strcat(command, "AND ");
+    }
+    strcat(command, ";");
+    
+    // execute add command
+    ExecuteCommand();
+
+    return 0;
+}
+
+// cbr add a row
+int32_t 
+CBR::AddRow(char *_cols[], float *_vals, unsigned int _len)
+{
+    unsigned int i;
+    
+    // generate command
+    strcpy(command, "insert into ");
+    strcat(command, tablename);
+    
+    strcat(command, " (");
+    for (i=0; i<_len; i++) {
+        strcat(command, _cols[i]);
+        if (i != numColumns-1) // not last entry
+            strcat(command, ", ");
+    }
+    strcat(command, ") ");
+
+    strcat(command, " values(");
+    for (i=0; i<_len; i++) {
+        // ???? how to fill the values if _cbr->numColumns != _len
+        // assume = in the following
+        sprintf(command, "%s%f", command, _vals[i]);
+        if (i != numColumns-1) // not last entry
+            strcat(command, ", ");
+    }
+    strcat(command, ");");
+    
+    // execute add command
+    ExecuteCommand();
+
+    return 0;
+}
 
 #endif