[Avida-SVN] r2361 - branches/uml/source/main
hjg at myxo.css.msu.edu
hjg at myxo.css.msu.edu
Fri Feb 22 10:04:34 PST 2008
Author: hjg
Date: 2008-02-22 13:04:33 -0500 (Fri, 22 Feb 2008)
New Revision: 2361
Added:
branches/uml/source/main/cMDEPropertyGenerator.cc
branches/uml/source/main/cMDEPropertyGenerator.h
Log:
Added: branches/uml/source/main/cMDEPropertyGenerator.cc
===================================================================
--- branches/uml/source/main/cMDEPropertyGenerator.cc (rev 0)
+++ branches/uml/source/main/cMDEPropertyGenerator.cc 2008-02-22 18:04:33 UTC (rev 2361)
@@ -0,0 +1,261 @@
+
+#include "cMDEPropertyGenerator.h"
+
+#include <sys/types.h>
+#include <sys/wait.h>
+#include <iomanip>
+#include <errno.h>
+
+
+using namespace std;
+
+cMDEPropertyGenerator::cMDEPropertyGenerator() {
+ //init property data
+ expression_p = 0;
+ expression_q = 0;
+ expression_r = 0;
+ m_property_reward = 0;
+ m_property_success =0;
+ m_property_failure =0;
+ m_absence_property_success =0;
+ m_absence_property_failure =0;
+ m_existence_property_success =0;
+ m_existence_property_failure =0;
+ m_universal_property_success =0;
+ m_universal_property_failure =0;
+ m_precedence_property_success =0;
+ m_precedence_property_failure =0;
+ m_response_property_success =0;
+ m_response_property_failure =0;
+}
+
+
+cMDEPropertyGenerator::~cMDEPropertyGenerator()
+{
+ for( std::set<cMDEProperty*, ltcMDEProperty>::iterator it = mdeprops.begin(),
+ e = mdeprops.end(); it != e; )
+ {
+ cMDEProperty *p = *it;
+ mdeprops.erase(it++);
+ delete p;
+ }
+
+}
+
+
+float cMDEPropertyGenerator::addExistenceProperty(std::string s)
+{
+ // a pointer to the existence property
+ float val = 0;
+ cMDEExistenceProperty e(s);
+
+ // first, try to find the property
+ //
+ std::set<cMDEProperty*, ltcMDEProperty>::iterator mdepropiter = mdeprops.find(&e);
+ if (mdepropiter != mdeprops.end()) {
+ val = (*mdepropiter)->getEvaluationInformation();
+ } else {
+ e.evaluate();
+ val = e.getEvaluationInformation();
+ mdeprops.insert(new cMDEExistenceProperty(e));
+ if (val >0) {
+ m_property_success++;
+ m_existence_property_success++;
+ } else {
+ m_property_failure++;
+ m_existence_property_failure++;
+ }
+ }
+
+ return val;
+}
+
+float cMDEPropertyGenerator::addAbsenceProperty(std::string s)
+{
+ // a pointer to the absence property
+ float val = 0;
+ cMDEAbsenceProperty e(s);
+
+ std::set<cMDEProperty*, ltcMDEProperty>::iterator mdepropiter = mdeprops.find(&e);
+ if (mdepropiter != mdeprops.end()) {
+ val = (*mdepropiter)->getEvaluationInformation();
+ } else {
+ e.evaluate();
+ val = e.getEvaluationInformation();
+ mdeprops.insert (new cMDEAbsenceProperty(e));
+ if (val >0) {
+ m_property_success++;
+ m_absence_property_success++;
+ } else {
+ m_property_failure++;
+ m_absence_property_failure++;
+ }
+ }
+
+ return val;
+
+}
+
+float cMDEPropertyGenerator::addUniversalProperty(std::string s)
+{
+ // a pointer to the universal property
+ float val = 0;
+ cMDEUniversalProperty e(s);
+
+ std::set<cMDEProperty*, ltcMDEProperty>::iterator mdepropiter = mdeprops.find(&e);
+ if (mdepropiter != mdeprops.end()) {
+ val = (*mdepropiter)->getEvaluationInformation();
+ } else {
+ e.evaluate();
+ val = e.getEvaluationInformation();
+ mdeprops.insert (new cMDEUniversalProperty(e));
+ if (val >0) {
+ m_property_success++;
+ m_universal_property_success++;
+ } else {
+ m_property_failure++;
+ m_universal_property_failure++;
+ }
+ }
+
+ return val;
+
+}
+
+
+
+// Check if the expression exists in the vector. If not, add it.
+bool cMDEPropertyGenerator::addExpression(std::string s, std::set<std::string> t)
+{
+ bool val = false;
+ cMDEExpression e;
+ e.setExpr(s);
+ e.setRelatedClasses(t);
+ std::vector<cMDEExpression>::iterator exprit;
+ exprit = find(expressions.begin(), expressions.end(), e);
+ if (exprit == expressions.end()) {
+ expressions.push_back(e);
+ val = true;
+ }
+ return val;
+}
+
+// AND expressions p & q to create a new expression
+// return true if this is a new expression
+// return false otherwise
+bool cMDEPropertyGenerator::ANDExpressions()
+{
+ bool val = false;
+ std::set<std::string> class_names, class_names2;
+ std::set<std::string>::iterator c;
+ std::string totalstring;
+ cMDEExpression p, q;
+
+ if (expression_p != expression_q){
+ p = getP();
+ q = getQ();
+ totalstring = "(" + p.getExpr() + " && " + q.getExpr() + ")";
+
+ class_names = p.getRelatedClasses();
+ class_names2 = q.getRelatedClasses();
+
+ for (c=class_names2.begin(); c != class_names2.end(); c++) {
+ class_names.insert(*c);
+ }
+
+ val = addExpression(totalstring, class_names);
+ }
+ return (val);
+}
+
+// OR expressions p & q to create a new expression
+// return true if this is a new expression
+// return false otherwise
+bool cMDEPropertyGenerator::ORExpressions()
+{
+
+ bool val = false;
+ std::set<std::string> class_names, class_names2;
+ std::set<std::string>::iterator c;
+ std::string totalstring;
+ cMDEExpression p, q;
+
+ if (expression_p != expression_q){
+ p = getP();
+ q = getQ();
+
+ class_names = p.getRelatedClasses();
+ class_names2 = q.getRelatedClasses();
+
+ for (c=class_names2.begin(); c != class_names2.end(); c++) {
+ class_names.insert(*c);
+ }
+
+ totalstring = "(" + p.getExpr() + " || " + q.getExpr() + ")";
+ val = addExpression(totalstring, class_names);
+ }
+ return (val);
+}
+
+float cMDEPropertyGenerator::addResponseProperty(std::string s1, std::string s2)
+{
+ // a pointer to the universal property
+ float val = 0;
+ cMDEResponseProperty e(s1, s2);
+
+ std::set<cMDEProperty*, ltcMDEProperty>::iterator mdepropiter = mdeprops.find(&e);
+ if (mdepropiter != mdeprops.end()) {
+ val = (*mdepropiter)->getEvaluationInformation();
+ } else {
+ e.evaluate();
+ val = e.getEvaluationInformation();
+ mdeprops.insert (new cMDEResponseProperty(e));
+ if (val >0) {
+ m_property_success++;
+ m_response_property_success++;
+ } else {
+ m_property_failure++;
+ m_response_property_failure++;
+ }
+ }
+ return val;
+}
+
+float cMDEPropertyGenerator::addPrecedenceProperty(std::string s1, std::string s2)
+{
+ // a pointer to the universal property
+ float val = 0;
+ cMDEPrecedenceProperty e(s1, s2);
+
+ std::set<cMDEProperty*, ltcMDEProperty>::iterator mdepropiter = mdeprops.find(&e);
+ if (mdepropiter != mdeprops.end()) {
+ val = (*mdepropiter)->getEvaluationInformation();
+ } else {
+ e.evaluate();
+ val = e.getEvaluationInformation();
+ mdeprops.insert (new cMDEPrecedenceProperty(e));
+ if (val >0) {
+ m_property_success++;
+ m_precedence_property_success++;
+ } else {
+ m_property_failure++;
+ m_precedence_property_failure++;
+ }
+ }
+ return val;
+
+}
+
+
+
+void cMDEPropertyGenerator::printExpressions()
+{
+ std::vector<cMDEExpression>::iterator exprit;
+ for (exprit = expressions.begin(); exprit < expressions.end(); exprit++){
+ std::cout << exprit->getExpr() << std::endl;
+ }
+
+}
+
+
+
Added: branches/uml/source/main/cMDEPropertyGenerator.h
===================================================================
--- branches/uml/source/main/cMDEPropertyGenerator.h (rev 0)
+++ branches/uml/source/main/cMDEPropertyGenerator.h 2008-02-22 18:04:33 UTC (rev 2361)
@@ -0,0 +1,148 @@
+#ifndef _C_MDEPROPERTYGENERATOR_H_
+#define _C_MDEPROPERTYGENERATOR_H_
+
+#include "cMDEProperty.h"
+#include "cMDEExistenceProperty.h"
+#include "cMDEAbsenceProperty.h"
+#include "cMDEUniversalProperty.h"
+#include "cMDEResponseProperty.h"
+#include "cMDEPrecedenceProperty.h"
+#include "cMDEExpression.h"
+
+#include <string>
+#include <iostream>
+#include <map>
+#include <utility>
+#include <algorithm>
+#include <set>
+#include <vector>
+#include <fstream>
+
+
+class cMDEPropertyGenerator {
+public:
+ cMDEPropertyGenerator();
+ ~cMDEPropertyGenerator();
+
+ // Get info about the properties satisfied by the model.
+ int numSuccess() { return m_property_success; }
+ int numFailure() { return m_property_failure; }
+ int numTotalProperty() { return m_property_success + m_property_failure; }
+ int numAbsencePropertySuccess() { return m_absence_property_success; }
+ int numAbsencePropertyFailure() { return m_absence_property_failure; }
+ int numAbsencePropertyTotal() { return m_absence_property_success + m_absence_property_failure; }
+ int numExistencePropertySuccess() { return m_existence_property_success; }
+ int numExistencePropertyFailure() { return m_existence_property_failure; }
+ int numExistencePropertyTotal() {
+ return m_existence_property_success + m_existence_property_failure; }
+ int numUniversalPropertySuccess() { return m_universal_property_success; }
+ int numUniversalPropertyFailure() { return m_universal_property_failure; }
+ int numUniversalPropertyTotal() {
+ return m_universal_property_success + m_universal_property_failure; }
+ int numPrecedencePropertySuccess() { return m_precedence_property_success; }
+ int numPrecedencePropertyFailure() { return m_precedence_property_failure; }
+ int numPrecedencePropertyTotal() {
+ return m_precedence_property_success + m_precedence_property_failure; }
+ int numResponsePropertySuccess() { return m_response_property_success; }
+ int numResponsePropertyFailure() { return m_response_property_failure; }
+ int numResponsePropertyTotal() { return m_response_property_success + m_response_property_failure; }
+
+ int propertySize() { return mdeprops.size(); }
+
+ void resetPropertyReward() { m_property_reward = 0; }
+ void addPropertyReward(float x) { m_property_reward += x; }
+ float getPropertyReward() { return m_property_reward; }
+
+
+ // Properties
+ float addExistenceProperty(std::string);
+ float addAbsenceProperty(std::string);
+ float addUniversalProperty(std::string);
+ float addResponseProperty(std::string, std::string);
+ float addPrecedenceProperty(std::string, std::string);
+
+ bool addExpression(std::string, std::set<std::string>);
+// bool relatedExpressions(cMDEExpression*, cMDEExpression*);
+ void printExpressions();
+
+ cMDEExpression getP() { return expressions[expression_p]; }
+ cMDEExpression getQ() { return (expressions[expression_q]); }
+ cMDEExpression getR() { return (expressions[expression_r]); }
+ std::string getPstring() { return (expressions[expression_p]).getExpr(); }
+ std::string getQstring() { return (expressions[expression_q]).getExpr(); }
+ std::string getRstring() { return (expressions[expression_r]).getExpr(); }
+ bool relativeMoveExpressionP(int x) { return relativeMoveIndex(expressions, expression_p, x); }
+ bool absoluteMoveExpressionP(int x) { return absoluteMoveIndex(expressions, expression_p, x); }
+ bool relativeMoveExpressionQ(int x) { return relativeMoveIndex(expressions, expression_q, x); }
+ bool absoluteMoveExpressionQ(int x) { return absoluteMoveIndex(expressions, expression_q, x); }
+ bool relativeMoveExpressionR(int x) { return relativeMoveIndex(expressions, expression_r, x); }
+ bool absoluteMoveExpressionR(int x) { return absoluteMoveIndex(expressions, expression_r, x); }
+
+ bool ANDExpressions();
+ bool ORExpressions();
+ template <typename T>
+ bool absoluteMoveIndex (T x, int &y, int z)
+ {
+
+ int x_size = (int) x.size();
+ if (x_size == 0 || z > x_size) {
+ return false;
+ }
+
+ y = 0;
+ return relativeMoveIndex(x, y, z);
+ }
+
+ template <typename T>
+ bool relativeMoveIndex (T x, int &y, int z)
+ {
+ int x_size = (int) x.size();
+
+ if (x_size == 0) {
+ return false;
+ }
+
+ if (z > 0) {
+ y += (z % x_size);
+
+ // index is greater than vector
+ if (y >= x_size) {
+ y -= x_size;
+ } else if(index < 0) {
+ y += x_size;
+ }
+ }
+ return true;
+ }
+
+
+protected:
+ int expression_p;
+ int expression_q;
+ int expression_r;
+
+ // set of properties.
+ std::set<cMDEProperty*, ltcMDEProperty> mdeprops;
+ int m_property_success;
+ int m_property_failure;
+ int m_absence_property_success;
+ int m_absence_property_failure;
+ int m_existence_property_success;
+ int m_existence_property_failure;
+ int m_universal_property_success;
+ int m_universal_property_failure;
+ int m_precedence_property_success;
+ int m_precedence_property_failure;
+ int m_response_property_success;
+ int m_response_property_failure;
+ float m_property_reward;
+
+
+ // vector of expressions
+ std::vector<cMDEExpression> expressions;
+
+};
+
+
+
+#endif
More information about the Avida-cvs
mailing list