#include "stdafx.h"
#include "CInterFace.h"
#include <iostream>
using namespace std;
int main()
{
{
CInterFace c_interFace;
while (c_interFace.iGetAndExecuteCommand() != -1)
{
cout << "_______________________" << endl;
}
}
return 0;
}
#pragma once
#include <string>
using namespace std;
#define S_UNDEFINED "undef"
#define I_ERR_OK 0
#define I_ERR_VAR_WITH_INVALID_CHAR 1
#define S_ERR_VAR_WITH_INVALID_CHAR "Variable(s) with invalid char, loaded as: "
class CNode
{
enum e_nodeType
{
op1arg, op2arg, value, variable
};
friend class CTree;
public:
CNode(string sValue);
CNode(CNode &cOther);
~CNode();
private:
bool IsAnInteger();
bool IsOneArgOperator();
bool IsTwoArgsOperator();
bool IsVariable();
int SetTypeAndMaxChildren();
string toString();
string _value;
CNode **_children;
int _maxChildren;
int _definedChildren;
e_nodeType e_type;
};
#include "stdafx.h"
#include "CNode.h"
CNode::CNode(string sValue)
{
_value = sValue;
_definedChildren = 0;
SetTypeAndMaxChildren();
if (_maxChildren > 0)
{
_children = new CNode*[_maxChildren];
}
else
{
_children = nullptr;
}
}
CNode::CNode(CNode &cOther)
{
_value = cOther._value;
_maxChildren = cOther._maxChildren;
e_type = cOther.e_type;
if (_maxChildren > 0)
{
_children = new CNode*[_maxChildren];
for (_definedChildren = 0; _definedChildren < _maxChildren; _definedChildren++)
{
*(_children + _definedChildren) = new CNode(**(cOther._children + _definedChildren));
}
}
else
{
_children = nullptr;
}
}
CNode::~CNode()
{
if (_children != nullptr)
{
for (int i = 0; i < _maxChildren; i++)
{
delete *(_children + i);
}
delete _children;
_children = nullptr;
}
}
bool CNode::IsAnInteger()
{
return (_value.find_first_not_of("0123456789") == string::npos);
}
bool CNode::IsOneArgOperator()
{
return (_value == "sin" || _value == "cos");
}
bool CNode::IsTwoArgsOperator()
{
return (_value == "+" || _value == "-" || _value == "*" || _value == "/");
}
bool CNode::IsVariable()
{
bool bIsVar = true;
int i_size = _value.size();
for (int i = 0; i < i_size && bIsVar; i++)
{
char c_char = _value.at(i);
if (c_char < 48 || c_char > 122 || (c_char > 57 && c_char < 65) || (c_char > 90 && c_char < 97))
{
bIsVar = false;
}
}
return bIsVar;
}
int CNode::SetTypeAndMaxChildren()
{
if (IsAnInteger())
{
e_type = value;
_maxChildren = 0;
}
else if (IsTwoArgsOperator())
{
e_type = op2arg;
_maxChildren = 2;
}
else if (IsOneArgOperator())
{
e_type = op1arg;
_maxChildren = 1;
}
else
{
e_type = variable;
_maxChildren = 0;
if (!IsVariable())
{
_value = S_UNDEFINED;
return I_ERR_VAR_WITH_INVALID_CHAR;
}
}
return I_ERR_OK;
}
string CNode::toString()
{
string s_retString = _value;
for (int i = 0; i < _maxChildren; i++)
{
s_retString += (" " + (*(_children + i))->toString());
}
return s_retString;
}
#pragma once
#include "CNode.h"
#include <iostream>
#include <vector>
#define S_DEF_VAL "1"
#define S_OP_SIN "sin"
#define S_OP_COS "cos"
#define S_OP_ADD "+"
#define S_OP_SUB "-"
#define S_OP_MUL "*"
#define S_OP_DIV "/"
#define S_NOT_DEFINED_DEBUG_LOG "Not defined operation!"
#define I_ERR_EMPTY_TREE 2
#define S_ERR_EMPTY_TREE "Tree is empty!"
#define I_ERR_DIV_BY_ZERO 3
#define S_ERR_DIV_BY_ZERO "Dividing by zero!"
#define I_ERR_INVALID_EXPRESSION 4
#define S_ERR_IVALID_EXPRESSION "Invalid expresion! Loaded:\n"
class CTree
{
public:
CTree();
CTree(CTree &cOther);
~CTree();
CTree operator +(CTree &other);
void operator =(CTree &other);
vector<string>& vctrGetVariableVector();
int BuildTree(vector<string> &vctrLoadedTokens);
string toString();
double Evaluate(vector<int> &vctrLoadedVariables, int &iErrorCode);
private:
void AddIfNewVariable(string &sVariableName);
void DeleteIfWasVariable(string &sVariableName);
int BuildSubTree(CNode*& pcRootNode, vector<string> &vctrLoadedTokens);
int ValueForVariable(string sVarName, vector<int> &vctrLoadedVariables);
double CalculateSubtree(CNode *pcRootNode, vector<int> &vctrLoadedVariables, int &iErrorCode);
CNode *_root;
vector<string> _variables;
};
#include "stdafx.h"
#include "CTree.h"
CTree::CTree()
{
_root = nullptr;
}
CTree::CTree(CTree &cOther)
{
_variables = cOther._variables;
_root = new CNode(*cOther._root);
}
CTree::~CTree()
{
if (_root != nullptr)
{
delete _root;
_root = nullptr;
}
}
CTree CTree::operator +(CTree &cOther)
{
CTree c_newTree;
if (_root == nullptr)
{
if (cOther._root != nullptr)
{
c_newTree = cOther;
c_newTree._variables = cOther._variables;
}
}
else if (cOther._root != nullptr)
{
c_newTree = *this;
CNode* pc_currentNode = c_newTree._root;
if (pc_currentNode->_children == nullptr)
{
delete c_newTree._root;
c_newTree._root = new CNode(*cOther._root);;
}
else
{
while ((*pc_currentNode->_children)->_maxChildren > 0)
{
pc_currentNode = *pc_currentNode->_children;
}
c_newTree.DeleteIfWasVariable((*(pc_currentNode->_children))->_value);
delete *(pc_currentNode->_children);
*(pc_currentNode->_children) = new CNode(*cOther._root);;
}
for (int i = 0; i < cOther._variables.size(); i++)
{
c_newTree.AddIfNewVariable(cOther._variables.at(i));
}
}
return c_newTree;
}
void CTree::operator =(CTree &cOther)
{
_variables = cOther._variables;
if (_root != nullptr)
{
delete _root;
}
_root = new CNode(*cOther._root);
}
vector<string>& CTree::vctrGetVariableVector()
{
return _variables;
}
int CTree::BuildTree(vector<string> &vctrLoadedTokens)
{
if (_root != nullptr)
{
delete _root;
_variables.clear();
_root = nullptr;
}
return BuildSubTree(_root, vctrLoadedTokens);
}
int CTree::BuildSubTree(CNode*& pcRootNode, vector<string> &vctrLoadedTokens)
{
int i_errorCode = I_ERR_OK;
if (!vctrLoadedTokens.empty())
{
pcRootNode = new CNode(vctrLoadedTokens.at(0));
if (pcRootNode->e_type == CNode::variable)
{
AddIfNewVariable(pcRootNode->_value);
}
vctrLoadedTokens.erase(vctrLoadedTokens.begin());
}
else
{
i_errorCode = I_ERR_INVALID_EXPRESSION;
pcRootNode = new CNode(S_DEF_VAL);
}
for (; pcRootNode->_definedChildren < pcRootNode->_maxChildren; pcRootNode->_definedChildren++)
{
i_errorCode = BuildSubTree(*(pcRootNode->_children + pcRootNode->_definedChildren), vctrLoadedTokens);
}
return i_errorCode;
}
void CTree::AddIfNewVariable(string &sVariableName)
{
bool bFound = false;
int i_varCount = _variables.size();
for (int i = 0; i < i_varCount && !bFound; i++)
{
if (_variables.at(i) == sVariableName)
{
bFound = true;
}
}
if (!bFound)
{
_variables.push_back(sVariableName);
}
}
void CTree::DeleteIfWasVariable(string &sVariableName)
{
int i_varCount = _variables.size();
bool b_found = false;
for (int i = 0; i < i_varCount && !b_found; i++)
{
if (_variables.at(i) == sVariableName)
{
_variables.erase(_variables.begin() + i);
b_found = true;
}
}
}
string CTree::toString()
{
if (_root != nullptr)
{
return _root->toString();
}
}
double CTree::Evaluate(vector<int> &vctrLoadedVariables, int &iErrorCode)
{
if (_root == nullptr)
{
return iErrorCode = I_ERR_EMPTY_TREE;
}
else
{
iErrorCode = I_ERR_OK;
return CalculateSubtree(_root, vctrLoadedVariables, iErrorCode);
}
}
double CTree::CalculateSubtree(CNode *pcRootNode, vector<int> &vctrLoadedVariables, int &iErrorCode)
{
if (iErrorCode == I_ERR_OK)
{
switch (pcRootNode->e_type)
{
case CNode::value:
return stoi(pcRootNode->_value);
case CNode::variable:
return ValueForVariable(pcRootNode->_value, vctrLoadedVariables);
case CNode::op1arg:
if (pcRootNode->_value == S_OP_SIN)
{
return sin(CalculateSubtree(*pcRootNode->_children, vctrLoadedVariables, iErrorCode));
}
else if (pcRootNode->_value == S_OP_COS)
{
return cos(CalculateSubtree(*pcRootNode->_children, vctrLoadedVariables, iErrorCode));
}
case CNode::op2arg:
if (pcRootNode->_value == S_OP_ADD)
{
return CalculateSubtree(*pcRootNode->_children, vctrLoadedVariables, iErrorCode) + CalculateSubtree(*(pcRootNode->_children + 1), vctrLoadedVariables, iErrorCode);
}
else if (pcRootNode->_value == S_OP_SUB)
{
return CalculateSubtree(*pcRootNode->_children, vctrLoadedVariables, iErrorCode) - CalculateSubtree(*(pcRootNode->_children + 1), vctrLoadedVariables, iErrorCode);
}
else if (pcRootNode->_value == S_OP_MUL)
{
return CalculateSubtree(*pcRootNode->_children, vctrLoadedVariables, iErrorCode) * CalculateSubtree(*(pcRootNode->_children + 1), vctrLoadedVariables, iErrorCode);
}
else if (pcRootNode->_value == S_OP_DIV)
{
int i_divider = CalculateSubtree(*(pcRootNode->_children + 1), vctrLoadedVariables, iErrorCode);
if (i_divider == 0)
{
iErrorCode = I_ERR_DIV_BY_ZERO;
return stod(S_DEF_VAL);
}
else return CalculateSubtree(*pcRootNode->_children, vctrLoadedVariables, iErrorCode) / i_divider;
}
break;
}
}
else
{
return stod(S_DEF_VAL);
}
}
int CTree::ValueForVariable(string sVarName, vector<int> &vctrLoadedVariables)
{
bool b_isFound = false;
int i_varCount = (vctrLoadedVariables.size() < _variables.size()) ? vctrLoadedVariables.size() : _variables.size();
int i_value = 0;
for (int i = 0; i < i_varCount && !b_isFound; i++)
{
if (_variables.at(i) == sVarName)
{
i_value = vctrLoadedVariables.at(i);
b_isFound = true;
}
}
return i_value;
}
#pragma once
#include "CTree.h"
#include <iostream>
#include <string>
#include <vector>
using namespace std;
#define S_CMD_ENTER "enter"
#define S_CMD_VARS "vars"
#define S_CMD_PRINT "print"
#define S_CMD_COMP "comp"
#define S_CMD_JOIN "join"
#define S_CMD_EXIT "exit"
#define S_RESULT "result: "
#define I_ERR_INVALID_ARGUMENT 5
#define S_ERR_INVALID_ARGUMENT "Invalid argument!"
#define I_ERR_NOT_ENOUGH_ARGUMENTS 6
#define S_ERR_NOT_ENOUGH_ARGUMENTS "Not enough arguments!"
#define I_ERR_TOO_MANY_ARGUMENTS 7
#define S_ERR_TOO_MANY_ARGUMENTS "Too many arguments!"
#define I_ERR_UNRECOGNISED_COMMAND 8
#define S_ERR_UNRECOGNISED_COMMAND "Unrecognised command!"
#define I_END_PROGRAM -1
class CInterFace
{
public:
CInterFace();
~CInterFace();
int iGetAndExecuteCommand();
int iProceedJoin();
vector<string> vctr_loadedTokens;
private:
void vSplit(vector<string> &result, string str, char delim);
int iProceedEnter();
int iProceedVars();
int iProceedPrint();
int iProceedComp();
int iProceedExit();
bool bIsAnPositiveInteger(string sStr);
CTree c_tree;
};
#include "stdafx.h"
#include "CInterFace.h"
CInterFace::CInterFace()
{
}
CInterFace::~CInterFace()
{
}
int CInterFace::iGetAndExecuteCommand()
{
cin.clear();
string s_Line;
getline(cin, s_Line);
vSplit(vctr_loadedTokens, s_Line, ' ');
int i_errorCode;
string s_command = vctr_loadedTokens.at(0);
vctr_loadedTokens.erase(vctr_loadedTokens.begin());
if (s_command == S_CMD_ENTER)
{
i_errorCode = iProceedEnter();
}
else if (s_command == S_CMD_VARS)
{
i_errorCode = iProceedVars();
}
else if (s_command == S_CMD_PRINT)
{
i_errorCode = iProceedPrint();
}
else if (s_command == S_CMD_COMP)
{
i_errorCode = iProceedComp();
}
else if (s_command == S_CMD_JOIN)
{
i_errorCode = iProceedJoin();
}
else if (s_command == S_CMD_EXIT)
{
i_errorCode = iProceedExit();
}
else
{
i_errorCode = I_ERR_UNRECOGNISED_COMMAND;
}
switch (i_errorCode)
{
case I_ERR_VAR_WITH_INVALID_CHAR: cout << S_ERR_VAR_WITH_INVALID_CHAR << S_UNDEFINED << endl; break;
case I_ERR_EMPTY_TREE: cout << S_ERR_EMPTY_TREE << endl; break;
case I_ERR_DIV_BY_ZERO: cout << S_ERR_DIV_BY_ZERO << endl; break;
case I_ERR_INVALID_EXPRESSION: cout << S_ERR_IVALID_EXPRESSION << c_tree.toString() << endl; break;
case I_ERR_INVALID_ARGUMENT: cout << S_ERR_INVALID_ARGUMENT << endl; break;
case I_ERR_NOT_ENOUGH_ARGUMENTS: cout << S_ERR_NOT_ENOUGH_ARGUMENTS << endl; break;
case I_ERR_TOO_MANY_ARGUMENTS: cout << S_ERR_TOO_MANY_ARGUMENTS << endl; break;
case I_ERR_UNRECOGNISED_COMMAND: cout << S_ERR_UNRECOGNISED_COMMAND << endl; break;
}
return i_errorCode;
}
void CInterFace::vSplit(vector<string> &result, string str, char delim)
{
string tmp = "";
result.clear();
for (string::iterator i = str.begin(); i < str.end(); ++i)
{
if ((const char)*i != delim && i != str.end())
{
tmp += *i;
}
else
{
if (tmp != "")
{
result.push_back(tmp);
}
tmp = "";
}
}
if (tmp != "")
{
result.push_back(tmp);
}
}
int CInterFace::iProceedEnter()
{
return c_tree.BuildTree(vctr_loadedTokens);
}
int CInterFace::iProceedVars()
{
if (vctr_loadedTokens.empty())
{
int i_varCount = c_tree.vctrGetVariableVector().size();
for (int i = 0; i < i_varCount; i++)
{
cout << c_tree.vctrGetVariableVector().at(i) << "\t";
}
cout << endl;
return I_ERR_OK;
}
else
{
return I_ERR_TOO_MANY_ARGUMENTS;
}
}
int CInterFace::iProceedPrint()
{
if (vctr_loadedTokens.empty())
{
cout << c_tree.toString() << endl;
return I_ERR_OK;
}
else
{
return I_ERR_TOO_MANY_ARGUMENTS;
}
}
int CInterFace::iProceedComp()
{
int i_varsCount = c_tree.vctrGetVariableVector().size();
int i_tokensCount = vctr_loadedTokens.size();
if (i_tokensCount > i_varsCount) { return I_ERR_TOO_MANY_ARGUMENTS; }
if (i_tokensCount < i_varsCount) { return I_ERR_NOT_ENOUGH_ARGUMENTS; }
bool b_argsCorrect = true;
vector<int> vctr_loadedVars;
string sActToken;
for (int i = 0; i < i_tokensCount && b_argsCorrect; i++)
{
sActToken = vctr_loadedTokens.at(i);
if (bIsAnPositiveInteger(sActToken))
{
vctr_loadedVars.emplace_back(stoi(sActToken));
}
else
{
b_argsCorrect = false;
}
}
if (!b_argsCorrect)
{
return I_ERR_INVALID_ARGUMENT;
}
int i_errCode = I_ERR_OK;
double d_potResult = c_tree.Evaluate(vctr_loadedVars, i_errCode);
if (i_errCode == I_ERR_OK)
{
cout << S_RESULT << d_potResult << endl;
}
return i_errCode;
}
int CInterFace::iProceedJoin()
{
CTree newTree;
int i_errorCode = newTree.BuildTree(vctr_loadedTokens);
c_tree = c_tree + newTree;
return i_errorCode;
}
int CInterFace::iProceedExit()
{
return I_END_PROGRAM;
}
bool CInterFace::bIsAnPositiveInteger(string sStr)
{
return (sStr.find_first_not_of("0123456789") == std::string::npos) && stoi(sStr) > 0;
}
