Ejemplo n.º 1
0
    void InfixToPostfix::loadMathOperators() {
        addOperator("^");
        addOperator("/ * %");
        addOperator("sin cos tan sinh cosh tanh");
        addOperator("+ -");

    }
Ejemplo n.º 2
0
bool  parserCls::factor(void)
{ EtokenType lTt1 = getTokenType();bool bb1 = true ;
  tokenContainCls lTc1 =getCurToken() ,lTc2;bool seeUnary= false;


  if( (lTt1 == Plus) || (lTt1==Minus) || (lTt1 == Not) )
  { if(lTt1== Plus)	 lTc1.type = UnaryPlus;
	 else if(lTt1== Minus) lTc1 . type = UnaryMinus;
	 lTc2=lTc1;getToken();lTt1=getTokenType();
	 lTc1=getCurToken();seeUnary=true;
  }
  switch(lTt1){
	 case OrdNumber:case SciNumber:case Array :
	addOperand() ;exprFound = true ;needOperand = false ;getToken();
	 break ;
	 case String :
		 if(seeUnary)
	 {errorUnary(lTc2 ,1);bb1 = false;break ;}
		 addOperand();exprFound=true;needOperand=false ;getToken();
	 break ;
	 case Name : exprFound = true ;needOperand=false;getToken();
	if(getTokenType() == Lparen ) bb1=addFunction(lTc1);
	else   addName(lTc1) ;
	 break ;
	 case Lparen :recursiveLparen() ;break ;
	 case Rparen :if(seeUnary)
		 {errorUnary(lTc2 , 2);bb1 = false ;break ;}
	 break ;
	 default :if(needOperand)	 errorFactor();
	  bb1 = false ;
	 break ;
  }
  if(seeUnary && bb1)	addOperator(lTc2);
  return bb1 ;
}
Ejemplo n.º 3
0
//-----------------------------------------------------------------------
void OperatorManager::applyOperator(Operator* op)
{
    assert(op);

    op->redo();
    addOperator(op);
}
Ejemplo n.º 4
0
   RTN_COORD_OP_END

   rtnCoordProcesserFactory::rtnCoordProcesserFactory()
   {
      addCommand();
      addOperator();
   }
Ejemplo n.º 5
0
Measurement::Measurement(MatrixXcd observable)
{
    ComplexEigenSolver<MatrixXcd> solver(observable);
    MatrixXcd vectors = solver.eigenvectors();
    for (int i = 0; i < vectors.cols(); ++i)
	addOperator(vectors.col(i) * vectors.col(i).transpose(), i_to_string(i));    
    _checkOperatorsAreValid();
}
Ejemplo n.º 6
0
Proector::Proector(HilbertSpace space)
{
    for (int i = 0; i < space.totalDimension(); ++i) {
	VectorXi toLabel = space.getVector(i);
	VectorXcd op = space.getBasisVector(toLabel);
	addOperator(op * op.transpose(), _vecToLabel(toLabel));
    }
}
Ejemplo n.º 7
0
void Tptp::addTheory(Theory theory) {
  ExprManager * em = getExprManager();
  switch(theory) {
  case THEORY_CORE:
    //TPTP (CNF and FOF) is unsorted so we define this common type
    {
      std::string d_unsorted_name = "$$unsorted";
      d_unsorted = em->mkSort(d_unsorted_name);
      preemptCommand( new DeclareTypeCommand(d_unsorted_name, 0, d_unsorted) );
    }
    // propositionnal
    defineType("Bool", em->booleanType());
    defineVar("$true", em->mkConst(true));
    defineVar("$false", em->mkConst(false));
    addOperator(kind::AND);
    addOperator(kind::EQUAL);
    addOperator(kind::IMPLIES);
    //addOperator(kind::ITE); //only for tff thf
    addOperator(kind::NOT);
    addOperator(kind::OR);
    addOperator(kind::XOR);
    addOperator(kind::APPLY_UF);
    //Add quantifiers?
    break;

  default:
    std::stringstream ss;
    ss << "internal error: Tptp::addTheory(): unhandled theory " << theory;
    throw ParserException(ss.str());
  }
}
Ejemplo n.º 8
0
bool   parserCls::term5(void)
{  bool s1 = term6();if(s1==false) return false ;
   EtokenType et1 =  getTokenType();tokenContainCls t1 ;
   while( (et1== Mul )||(et1 == Div )|| (et1 == Mod))
   { t1 =getCurToken();getToken();bool s2 = term6();
	  if(s2==false)	 return false ;
     addOperator(t1);et1 = getTokenType();
   }
   return  s1 ;
}
Ejemplo n.º 9
0
bool   parserCls::term6(void)
{ bool s1 = factor();if(s1==false) return false ;
  EtokenType et1 =  getTokenType();tokenContainCls t1 ;
  if(et1== Pow)
  { t1 =getCurToken(); getToken(); bool s2 = factor();
	 if(s2==false) return false ;
	 addOperator(t1); et1 = getTokenType();
  }
  return  s1 ;
}
Ejemplo n.º 10
0
bool   parserCls::term2(void)
{  bool s1 = term3();if(s1==false) return false ;
   EtokenType et1=getTokenType();tokenContainCls t1 ;
   if((et1==ExEq)||(et1==Ne)||(et1==Ge)||(et1==Le)||
	  (et1==Gt)||(et1==Lt)||(et1==Eq)  )
   {   t1=getCurToken();getToken();bool s2 = term3();
       if(s2==false)	 return false ;
       addOperator(t1);et1 = getTokenType();
   }
   return  s1 ;
}
Ejemplo n.º 11
0
/// fa+b,c+d)
/// f is the name of function
// one error not checked f(a,,b)
bool parserCls::addFunction(tokenContainCls &lTc1)
{ lTc1.type = FunctionName; addOperand(lTc1);bool bb2 = true ;
  bool bb3=false;EtokenType  lt1;int iiExpr12=0,indexX=noTokenInExpr++;
  addOperand(lTc1); // for stack for change after end
 do{ if(bb3)	addOperand();
	  else 	 bb3 = true ;

	  getToken();// get next token after (
	  if(!term1() ){ bb2 = false   ;break ;}
	  if((noTokenInExpr-2) > (indexX))
			iiExpr12++;
	  lt1= getTokenType();
 }while((lt1==Comma));
 if(bb2) if(lt1 != Rparen)
	 {bb2 = false; errorRecursLparen(1, lTc1);}
 else {addOperator();getToken();}
 tokenContainCls lTc2(iiExpr12,1);
  addOperator(indexX, lTc2);
 return bb2 ;
}
Ejemplo n.º 12
0
bool   parserCls::term3(void)
{ bool s1 = term4();if(s1==false) return false ;
  EtokenType et1 =  getTokenType();tokenContainCls t1 ;
  while( (et1== Concat ) )
  {  t1 =getCurToken();getToken();bool s2 = term4();
     if(s2==false) return false ;
     addOperator(t1);
	  et1 = getTokenType();
  }
  return  s1 ;
}
Ejemplo n.º 13
0
void Expression::buildBytecodePostfix(OperationCode *opcode, Parser *parser) {
	for (list<ExpressionTerm*>::iterator it = postfix.begin(); it != postfix.end(); it++) {
			ExpressionTerm *term = *it;

			if (expressionVars.count(term) != 0) {
				opcode->addInterop(new ByteOperation(OP_PUSH));
				opcode->addInterop(new DwordOperation(&expressionVars[term]));
			} else {
				addOperator(opcode, term->token);
			}
	}
}
Ejemplo n.º 14
0
bool   parserCls::term1(void)
{ bool s1 = term2();
  if(s1==false) return false ;
  EtokenType et1=getTokenType();tokenContainCls t1 ;
  while( (et1== And )||(et1 == Or )|| (et1 == ExOr))
  {
	  t1 =getCurToken();getToken();bool s2 = term2();
	  if(s2==false) return false ;
	  addOperator(t1);et1 = getTokenType();
  }
  return  s1 ;
}
void GeneratorObjectImplementation::synchronizedUIListen(SceneObject* player, int value) {
	if (!player->isPlayerCreature() || !isOnAdminList(cast<CreatureObject*>(player)) || getZone() == NULL)
		return;

	addOperator(cast<CreatureObject*>(player));

	updateInstallationWork();

	HarvesterObjectMessage7* msg = new HarvesterObjectMessage7(_this.getReferenceUnsafeStaticCast());
	player->sendMessage(msg);

	activateUiSync();
}
Ejemplo n.º 16
0
FreeWill::OperatorDescriptorHandle FreeWill::Model::addOperator(const std::string &name,
                                 const std::string &operatorNameString,
                                 const std::map<std::string, FreeWill::TensorDescriptorHandle> &inputs,
                                 const std::map<std::string, FreeWill::TensorDescriptorHandle> &outputs,
                                 const std::map<std::string, std::any> &properties, DataType dataType)
{
    if (FreeWill::operatorNameTable.find(operatorNameString) != FreeWill::operatorNameTable.end())
    {
        FreeWill::OperatorName operatorName = operatorNameTable[operatorNameString];

        return addOperator(name, operatorName, inputs, outputs, properties, dataType);

        return name;
    }

    return std::string();
}
Ejemplo n.º 17
0
bool  parserCls::factor(void)
{
  EtokenType lTt1 = getTokenType();
  bool bb1 = true ;
  tokenContainCls lTc1 =getCurToken();

  switch(lTt1)
  {
	 case OrdNumber:
	 case SciNumber:
	 case String :
	 case Array :
		  addOperand() ;

		  exprFound = true ;
		  needOperand = false ;
		noTokenInExpr++;

		  getToken();
	 break ;
	 case Name :

		 exprFound = true ;
		 needOperand = false ;
		 noTokenInExpr++;
		 getToken();
		 if(getTokenType() == Lparen )
			addFunction(lTc1);
		 else
			 addName(lTc1) ;
	 break ;
	 case Lparen :
		addOperator() ;
		recursiveLparen() ;
	 break ;
	 case Rparen :

	 break ;
	 default :
		if(needOperand)
			 errorFactor();
		 bb1 = false ;
	}
  return bb1 ;
}
Ejemplo n.º 18
0
bool   parserCls::contExpr(int ii1)
{
 bool b2 = !exprErrorFlag ;
 if(b2)
 {
	 if(tokenInExpr(ii1))
	 {
		b2 =true ;
		addOperator();
		getToken() ;
		needOperand = true ;
		noTokenInExpr++;
	 }
	 else
		b2 = false ;
 }
	return b2 ;
}
void HarvesterObjectImplementation::synchronizedUIListen(CreatureObject* player, int value) {
	if (!player->isPlayerCreature() || !isOnAdminList(player) || getZone() == NULL)
		return;

	addOperator(player);

	updateInstallationWork();

	HarvesterObjectMessage7* msg = new HarvesterObjectMessage7(_this.getReferenceUnsafeStaticCast());
	player->sendMessage(msg);

	/// Have to send the spawns of items no in shift, or the dont show
	/// up in the hopper when you look.
	for (int i = 0; i < resourceHopper.size(); ++i) {
		ResourceContainer* container = resourceHopper.get(i);

		if (container != NULL) {
			container->sendTo(player, true);
		}
	}

	activateUiSync();
}
Ejemplo n.º 20
0
OperatorFactory::OperatorFactory() {
    addOperator("+", spOp(new Add));
    addOperator("-", spOp(new Subtract));
    addOperator("!", spOp(new Factorial));
    addOperator("*", spOp(new Multiply));
    addOperator("/", spOp(new Divide));
    addOperator("<", spOp(new LessThen));
    addOperator(">", spOp(new GreaterThen));
    addOperator("primeFactors", spOp(new PrimeFactors));
    addOperator("sum", spOp(new Sum));
    addOperator("drop", spOp(new Drop));
    addOperator("dup", spOp(new Dup));
    addOperator("ndup", spOp(new NDup));
    addOperator("nop", spOp(new Nop));
    addOperator("swap", spOp(new Swap));
    addOperator("ifElse", spOp(new IfElse(getOperatorNamed("nop"), getOperatorNamed("nop"))));
}
Ejemplo n.º 21
0
/** Append text to Expression. Overwrites a trailing operator with the new one, if a sequence of
  * two operators is input.
  * Recognizes and executes C, AC and = commands.
  */
void Calculator::addToExpressionText(const QString & buttonText)
{
    QString text = buttonText;
    try{
        if(text == "C")
            clearLast();
        else if(text == "AC")
            clearAll();
        else if(text == "+/-")
            changeSign();
        else if(text == m_TextRad)
            setAngleMode(text);
        else if(text == m_TextDeg)
            setAngleMode(text);
        else if(text == "=")
        {
            if(isPlotExpression())
                createPlot();
            else parseExpression();
        }
        else if(text=="x")
            addVariable(text);
        else if(text.startsWith("Plot"))
                plotter.processPlotCommand(text);
        else{ //we have a digit, operator or function
            //no clear or evaluate command
            if(text == "x^y") //convert to operator
                text = "^";
            if(isNumber(text)){ //No parenthesis, we have a digit or a decimal separator
                addDigit(text);
                emit guiStateSuggested(STATE_STANDARD); //return to std page, if on Fn Page for entering E
            }
            else if(isOperator(text)) //operator or digit
            {
                addOperator(text);
            }
            else if(isParenthesis(text)) //we have a parenthesis
            {
                addParenthesis(text);
            }
            else if(isFunction(text)) //we have a function
            {
                addFunctionCall(text);
            }
            else if(isVariable(text)) //we have a variable
            {
                addVariable(text);
            }
            else throw ExExpressionError(tr("Unknown command:") + text);

        } //end digit operator or function

        m_ExpressionText = m_ExpressionParts.join("");
        if(isPlotExpression())
            emit expressionTextChanged("y=" + m_ExpressionText);
        else emit expressionTextChanged(m_ExpressionText);
    } //end try
    catch(ExExpressionError e)
    {
        emit guiStateSuggested(STATE_STANDARD);
        emit errorMessage(tr("Input Error"),e.what());
    }
    catch(std::exception e)
    {
        emit guiStateSuggested(STATE_STANDARD);
        emit errorMessage(tr("Unknown Input Error"),e.what());
    }
}
Ejemplo n.º 22
0
Archivo: smt2.cpp Proyecto: neuroo/CVC4
void Smt2::addTheory(Theory theory) {
  switch(theory) {
  case THEORY_ARRAYS:
    Parser::addOperator(kind::SELECT);
    Parser::addOperator(kind::STORE);
    break;

  case THEORY_BITVECTORS:
    addBitvectorOperators();
    break;

  case THEORY_CORE:
    defineType("Bool", getExprManager()->booleanType());
    defineVar("true", getExprManager()->mkConst(true));
    defineVar("false", getExprManager()->mkConst(false));
    Parser::addOperator(kind::AND);
    Parser::addOperator(kind::DISTINCT);
    Parser::addOperator(kind::EQUAL);
    Parser::addOperator(kind::IFF);
    Parser::addOperator(kind::IMPLIES);
    Parser::addOperator(kind::ITE);
    Parser::addOperator(kind::NOT);
    Parser::addOperator(kind::OR);
    Parser::addOperator(kind::XOR);
    break;

  case THEORY_REALS_INTS:
    defineType("Real", getExprManager()->realType());
    Parser::addOperator(kind::DIVISION);
    Parser::addOperator(kind::TO_INTEGER);
    Parser::addOperator(kind::IS_INTEGER);
    Parser::addOperator(kind::TO_REAL);
    // falling through on purpose, to add Ints part of Reals_Ints
  case THEORY_INTS:
    defineType("Int", getExprManager()->integerType());
    addArithmeticOperators();
    Parser::addOperator(kind::INTS_DIVISION);
    Parser::addOperator(kind::INTS_MODULUS);
    Parser::addOperator(kind::ABS);
    Parser::addOperator(kind::DIVISIBLE);
    break;

  case THEORY_REALS:
    defineType("Real", getExprManager()->realType());
    addArithmeticOperators();
    Parser::addOperator(kind::DIVISION);
    break;

  case THEORY_QUANTIFIERS:
    break;

  case THEORY_SETS:
    addOperator(kind::UNION, "union");
    addOperator(kind::INTERSECTION, "intersection");
    addOperator(kind::SETMINUS, "setminus");
    addOperator(kind::SUBSET, "subset");
    addOperator(kind::MEMBER, "member");
    addOperator(kind::SINGLETON, "singleton");
    addOperator(kind::INSERT, "insert");
    break;

  case THEORY_DATATYPES:
    Parser::addOperator(kind::APPLY_CONSTRUCTOR);
    Parser::addOperator(kind::APPLY_TESTER);
    Parser::addOperator(kind::APPLY_SELECTOR);
    Parser::addOperator(kind::APPLY_SELECTOR_TOTAL);
    break;

  case THEORY_STRINGS:
    defineType("String", getExprManager()->stringType());
    addStringOperators();
    break;

  case THEORY_UF:
    Parser::addOperator(kind::APPLY_UF);
    break;

  default:
    std::stringstream ss;
    ss << "internal error: unsupported theory " << theory;
    throw ParserException(ss.str());
  }
}
Ejemplo n.º 23
0
 void InfixToPostfix::loadLogicalOperators() {
     addOperator("!");
     addOperator("or");
     addOperator("and");
 }