SentenceUnit.cpp

Go to the documentation of this file.

// SentenceUnit.cpp: implementation of the SentenceUnit class.
//
 
#include <algorithm>
#include <math.h>
 
#include "../Crew/OperatorDM.h"
#include "../Crew/OperatorAT.h"
#include "ReasonMachine.h"
#include "SentenceUnit.h"
#include "../Global/SimulationContext.h"
using namespace std;
 
 
// Construction/Destruction
 
SentenceUnit::SentenceUnit()
{
    this->m_Negation_bl = false;
    this->m_ID_Type =100;
    this->m_subject_pt = NULL;
    this->m_process_pt = NULL;
    this->m_state_pt = NULL;
    this->m_comparison_pt = NULL;
    this->m_object_pt = NULL;
    this->m_attribute_pt = NULL;
    this->m_delta_value = 0;
    this->m_value = 0;
    this->m_sentence_type = 0; // deterministic default
    this->m_ID_subject = "";
    this->m_ID_process = "";
    this->m_ID_object = "";
    this->m_ID_attribute = "";
    this->m_ID_comparison = "";
    this->m_ID_state = "";
}
 
SentenceUnit::~SentenceUnit()
{
/*  delete this->m_state_pt; //this is not used??
    delete this->m_comparison_pt;
    delete this->m_process_pt;
    delete this->m_attribute_pt;
    delete this->m_subject_pt;
    delete this->m_object_pt;
*/
}
 
bool SentenceUnit::CheckMatchBySentence(SentenceUnit * _sent_pt)
{
    bool match = true;
    if(this->m_sentence_type != _sent_pt->m_sentence_type)
    {
        match = false;
        return match;
    }
    if(this->m_subject_pt->m_ID != _sent_pt->m_subject_pt->m_ID)
    {
        match = false;
        return match;
    }
 
    switch (this->m_sentence_type) 
    {
    case 1: //process sentence
        if(this->m_process_pt->m_ID != _sent_pt->m_process_pt->m_ID)
        {match = false;}
        break;
    case 2: //state sentence
        if(this->m_state_pt->m_ID != _sent_pt->m_state_pt->m_ID)
        {match = false;}
        break;
    case 3: //comparison sentence //note: maybe more flexible way to compare?
        if(this->m_comparison_pt->m_ID != _sent_pt->m_comparison_pt->m_ID)
        {match = false;}
        if(this->m_value != _sent_pt->m_value)
        {match = false;}
        break;
    case 4: //comparison with the object
        if(this->m_comparison_pt->m_ID != _sent_pt->m_comparison_pt->m_ID)
        {match = false;}
        if(this->m_object_pt->m_ID != _sent_pt->m_object_pt->m_ID)
        {match = false;}
        if(this->m_delta_value != _sent_pt->m_delta_value)
        {match = false;}
        break;
    case 5://attributive sentence
        if(this->m_attribute_pt->m_ID != _sent_pt->m_attribute_pt->m_ID)
        {match = false;}
        break;
    default:
        //warning message, unrecoganized sentence type
        break;
    }
    return match;
}
 
void SentenceUnit::CopyFromAnotherSentence(SentenceUnit * _sent_pt)
{
    this->m_ID_Type = _sent_pt->m_ID_Type;
    this->m_sentence_type = _sent_pt->m_sentence_type;
    this->m_subject_pt = _sent_pt->m_subject_pt;
    // 1--process sentence, subject + process                   SG_A_Pressure increase
    // 2--subject + "is" + state word
    // 3--comparison sentence, subject  + ">/=/<" + value
    // 4--comparison sentence, subject + ">/=/<" + object
    // 5--attributive sentence, subject + "is" + attributive word
    // 6--definition or declaration, low_Tav + "is" + 563?
    switch (this->m_sentence_type)
    {
    case 1:
        this->m_process_pt = _sent_pt->m_process_pt;
        break;
    case 2:
        this->m_state_pt = _sent_pt->m_state_pt;
        break;
    case 3:
        this->m_comparison_pt = _sent_pt->m_comparison_pt;
        this->m_value = _sent_pt->m_value;
        break;
    case 4:
        this->m_comparison_pt = _sent_pt->m_comparison_pt;
        this->m_object_pt = _sent_pt->m_object_pt;
        this->m_delta_value = _sent_pt->m_delta_value;
        break;
    case 5:
        this->m_attribute_pt = _sent_pt->m_attribute_pt;
        break;
    }
    
}
 
void SentenceUnit::ActivationPropagationFromConceptBottomUp(int _operator)
{
    // 1--process sentence, subject + process                   SG_A_Pressure increase
    // 2--subject + "is" + state word
    // 3--comparison sentence, subject  + ">/=/<" + value
    // 4--comparison sentence, subject + ">/=/<" + object
    // 5--attributive sentence, subject + "is" + attributive word
    // 6--definition or declaration, low_Tav + "is" + 563?
    ReasonMachine * RM_pt;
    if (_operator == sim::Operator::ODM)
    {RM_pt = g_sim.Decision_Maker.m_RM.get();}
    else if (_operator == sim::Operator::OAT)
    {RM_pt = g_sim.Action_Taker.m_RM.get();}
    else
    {}//add error message
 
    this->m_old_activation = this->m_activation;
 
    double ratio = 1;   
    ratio = ratio * this->GetActivationChangeRatioByID(this->m_subject_pt);
    switch (this->m_sentence_type)
    {
    case 1:
        ratio = ratio * pow(this->GetActivationChangeRatioByID(this->m_process_pt), float(1/2.0));
        break;
    case 2:
        ratio = ratio * pow(this->GetActivationChangeRatioByID(this->m_state_pt), float(1/2.0));
        break;
    case 3:
        ratio = ratio * pow(this->GetActivationChangeRatioByID(this->m_comparison_pt), float(1/3.0));
        break;
    case 4:
        ratio = ratio * pow(this->GetActivationChangeRatioByID(this->m_comparison_pt),float(1/3.0));
        ratio = ratio * pow(this->GetActivationChangeRatioByID(this->m_object_pt),float(1/3.0));
        break;
    case 5:
        break;
        ratio = ratio * pow(this->GetActivationChangeRatioByID(this->m_attribute_pt),float(1/2.0));
    default:
        //error message
        break;
    }
    this->ChangeActivationByRatio((float)ratio);
    this->UpdateTheBaseLineValueAfterAChange((float)RM_pt->m_decay_lamda);
}
 
double SentenceUnit::GetActivationChangeRatioByID(IDElement * _ID_pt)
{
    double ratio = 1;
    ConceptBasicUnit * B_pt;
    ConceptComposedUnit * C_pt;
    switch (_ID_pt->m_ID_Type)
    {
    case 1:
        //ConceptBasicUnit
        B_pt = (ConceptBasicUnit *)_ID_pt;  
        ratio = B_pt->m_change_ratio;
    case 2:
        //ConceptComposedUnit
        C_pt = (ConceptComposedUnit *)_ID_pt;
        ratio = C_pt->m_change_ratio;
        break;
    default:
        //error message
        break;
    }
    return ratio;
}
 
void SentenceUnit::PropagateActivationToConceptUnitsTopDown(int _operator)
{
 
    double ratio1, ratio2;
    float n=1;
 
    // 1--process sentence, subject + process                   SG_A_Pressure increase
    // 2--subject + "is" + state word
    // 3--comparison sentence, subject  + ">/=/<" + value
    // 4--comparison sentence, subject + ">/=/<" + object
    // 5--attributive sentence, subject + "is" + attributive word
    // 6--definition or declaration, low_Tav + "is" + 563?
    ratio1 = this->m_change_ratio;
    switch (this->m_sentence_type)
    {
    case 1:
        n=2;
        ratio2 = pow(ratio1, float(1/n));
        this->ChangActivationOfConceptByID(this->m_subject_pt, ratio2, _operator);
        this->ChangActivationOfConceptByID(this->m_process_pt, ratio2, _operator);
        break;
    case 2:
        n=2;
        ratio2 = pow(ratio1, float(1/n));
        this->ChangActivationOfConceptByID(this->m_subject_pt, ratio2, _operator);
        this->ChangActivationOfConceptByID(this->m_state_pt, ratio2, _operator);
        break;
    case 3:
        n=3;
        ratio2 = pow(ratio1, float(1/n));
        this->ChangActivationOfConceptByID(this->m_subject_pt, ratio2, _operator);
        this->ChangActivationOfConceptByID(this->m_comparison_pt, ratio2, _operator);
        break;
    case 4:
        n=3;
        ratio2 = pow(ratio1, float(1/n));
        this->ChangActivationOfConceptByID(this->m_subject_pt, ratio2, _operator);
        this->ChangActivationOfConceptByID(this->m_comparison_pt, ratio2, _operator);
        this->ChangActivationOfConceptByID(this->m_object_pt, ratio2, _operator);
        break;
    case 5:
        n=2;
        ratio2 = pow(ratio1, float(1/n));
        this->ChangActivationOfConceptByID(this->m_subject_pt, ratio2, _operator);
        this->ChangActivationOfConceptByID(this->m_attribute_pt, ratio2, _operator);
        break;
    default:
        //error message
        break;
    }
}
 
void SentenceUnit::ChangActivationOfConceptByID(IDElement * _ID_pt, double _ratio, int _operator)
{
    ReasonMachine * RM_pt;
    if (_operator == sim::Operator::ODM)
    {RM_pt = g_sim.Decision_Maker.m_RM.get();}
    else if (_operator == sim::Operator::OAT)
    {RM_pt = g_sim.Action_Taker.m_RM.get();}
    else
    {}//add error message
 
    ConceptBasicUnit * B_pt;
    ConceptComposedUnit * C_pt;
    switch (_ID_pt->m_ID_Type)
    {
    case 001:
        B_pt = (ConceptBasicUnit *)_ID_pt;
        B_pt->ChangeActivationByRatio((float)_ratio);
        RM_pt->m_Concept_Base->m_BasicConcept_updated_list.push_back(B_pt);
        break;
    case 002:
        C_pt = (ConceptComposedUnit *)_ID_pt;
        C_pt->ChangeActivationByRatio((float)_ratio);
        RM_pt->m_Concept_Base->m_ComposedConcept_updated_list.push_back(C_pt);
        break;
    default:
        //error message
        break;
    }
}
 
void SentenceUnit::PrintMessage(string str)
{
    cout << "\n";
    cout << "Time: " << r5pars_.timesno << ":\n" << str << '\n';
 
    //test
    ofstream fout("RMI.txt", ios::app);
    fout <<"\n" << "Time: " << r5pars_.timesno << ":\n" << str << '\n';
    fout.close();
}
 
//DEL void SentenceUnit::PrintThisSentence()
//DEL {
//DEL   cout << this->m_ID << '\n';
//DEL }
 
IDElement * SentenceUnit::GetLabelOfThisSentence()
{
    IDElement * label_sub_pt = NULL;
    IDElement * label_obj_pt = NULL;
    ConceptComposedUnit * CC_pt;
    if(this->m_subject_pt->m_ID_Type == 002)
    {
        CC_pt = (ConceptComposedUnit *)(this->m_subject_pt);
        label_sub_pt = CC_pt->m_label_ID_pt;
    }
    if(this->m_object_pt != NULL){
        if(this->m_object_pt->m_ID_Type == 002)
        {
            CC_pt = (ConceptComposedUnit *)(this->m_object_pt);
            label_obj_pt = CC_pt->m_label_ID_pt;
        }
    }
    if(label_sub_pt != NULL && label_obj_pt == NULL)
    {
        return label_sub_pt;
    }
    else if(label_sub_pt == NULL && label_obj_pt != NULL)
    {
        return label_obj_pt;
    }
    else if(label_sub_pt == NULL && label_obj_pt == NULL)
    {
        return NULL;
    }
    else if(label_sub_pt == label_obj_pt)
    {
        return label_sub_pt;
    }
    else
    {
        this->ErrorMessage(this->m_ID + " has two labels, which is beyond the current source codes!");
        return NULL;
    }
}
 
void SentenceUnit::ErrorMessage(string str)
{
    cout << r5pars_.timesno << "  " << str << " in SentenceUnit.cpp" << '\n';
    ofstream fout("err messages.txt", ios::app);
    fout << r5pars_.timesno << "  " << str << '\n';
    fout.close();
    //r5pars_.terminateall = true;
}
 
 
 
bool SentenceUnit::WhetherItIsBiState()
{
    bool BiState_bl = true;
    IDElement * ID_pt;
    ConceptBasicUnit * CB_pt;
    switch (this->m_sentence_type)
    {
    case 1:
        ID_pt = this->m_process_pt;
        break;
    case 2:
        ID_pt = this->m_state_pt;
        break;
    case 3:
        ID_pt = this->m_comparison_pt;
        break;
    case 4:
        ID_pt = this->m_comparison_pt;
        break;
    case 5:
        ID_pt = this->m_attribute_pt;
        break;
    }
    if(ID_pt->m_ID_Type == 001)
    {
        CB_pt = (ConceptBasicUnit *)ID_pt;
        if(CB_pt->m_antonym_list.size() < 2)
        {
            BiState_bl = true;
        }
        else
        {
            BiState_bl = false;
        }
    }
    return BiState_bl;
}
 
void SentenceUnit::ConvertSentenceInfoToStringForm()
{
    this->m_ID_subject = this->m_subject_pt->m_ID;
 
    if(this->m_process_pt != NULL)
    {this->m_ID_process = this->m_process_pt->m_ID;}
 
    if(this->m_object_pt != NULL)
    {this->m_ID_object = this->m_object_pt->m_ID;}
 
    if(this->m_comparison_pt != NULL)
    {this->m_ID_comparison = this->m_comparison_pt->m_ID;}
 
    if(this->m_attribute_pt != NULL)
    {this->m_ID_attribute = this->m_attribute_pt->m_ID;}
 
    if(this->m_state_pt != NULL)
    {this->m_ID_state = this->m_state_pt->m_ID;}
}
 
void SentenceUnit::CopyStaticInfoFromAnotherSentence(SentenceUnit * _sent_pt)
{
    this->CopyActivationToRestartInfo((Activation*) _sent_pt);
    this->CopyIDElementToRestartInfo((IDElement*)_sent_pt);
 
    this->m_ID_subject = _sent_pt->m_ID_subject;
    this->m_ID_process = _sent_pt->m_ID_process;
    this->m_ID_object = _sent_pt->m_ID_object;
    this->m_ID_comparison = _sent_pt->m_ID_comparison;
    this->m_ID_attribute = _sent_pt->m_ID_attribute;
    this->m_ID_state = _sent_pt->m_ID_state;
/*
    double m_value;
    bool m_Negation_bl;
    float m_delta_value;
    int m_sentence_type; 
*/
 
    this->m_delta_value = _sent_pt->m_delta_value;
    this->m_value = _sent_pt->m_value;
    this->m_sentence_type = _sent_pt->m_sentence_type;
    this->m_Negation_bl = _sent_pt->m_Negation_bl;
 
}
 
void SentenceUnit::BuildTheConnectionsToThisSentence(void * _pt)
{
    ReasonMachine * RM_pt;
    RM_pt = (ReasonMachine *)_pt;
 
/*
    IDElement * m_state_pt; //this is not used??
    IDElement * m_comparison_pt;
    IDElement * m_process_pt;
    IDElement * m_attribute_pt;
    IDElement * m_subject_pt;
    IDElement * m_object_pt;
 
    string m_ID_state;
    string m_ID_subject;
    string m_ID_process;
    string m_ID_object;
    string m_ID_comparison;
    string m_ID_attribute;
*/
    this->m_subject_pt = RM_pt->m_Concept_Base->FindConceptByID(this->m_ID_subject);
    if(this->m_subject_pt == NULL)
    {this->ErrorMessage("could not find the subject" + this->m_ID_subject); return;}
 
    if(this->m_ID_process.compare("") != 0)
    {
        this->m_process_pt = RM_pt->m_Concept_Base->FindConceptByID(this->m_ID_process);
        if(this->m_process_pt == NULL)
        {this->ErrorMessage("could not find the process concept" + this->m_ID_process); return;}
    }
 
    if(this->m_ID_state.compare("") != 0)
    {
        this->m_state_pt = RM_pt->m_Concept_Base->FindConceptByID(this->m_ID_state);
        if(this->m_state_pt == NULL)
        {this->ErrorMessage("could not find the state concept" + this->m_ID_state); return;}
    }
 
    if(this->m_ID_object.compare("") != 0)
    {
        this->m_object_pt = RM_pt->m_Concept_Base->FindConceptByID(this->m_ID_object);
        if(this->m_object_pt == NULL)
        {this->ErrorMessage("could not find the object concept" + this->m_ID_object); return;}
    }
 
    if(this->m_ID_comparison.compare("") != 0)
    {
        this->m_comparison_pt = RM_pt->m_Concept_Base->FindConceptByID(this->m_ID_comparison);
        if(this->m_comparison_pt == NULL)
        {this->ErrorMessage("could not find the comparison concept" + this->m_ID_comparison); return;}
    }
 
    if(this->m_ID_attribute.compare("") != 0)
    {
        this->m_attribute_pt = RM_pt->m_Concept_Base->FindConceptByID(this->m_ID_attribute);
        if(this->m_attribute_pt == NULL)
        {this->ErrorMessage("could not find the attribute concept" + this->m_ID_attribute); return;}
    }
}