C++ Operator函数代码示例

void UnaryOpExpressionAST::typeCheck(TypeChecker& checker) {
	mOperand->typeCheck(checker);

	auto opType = mOperand->expressionType(checker);

	if (mOp == Operator('!') && opType != checker.findType("Bool")) {
		checker.typeError("The '!' operator can only be applied to values/variables of type 'Bool'.");
	} else if (mOp == Operator('-') && opType != checker.findType("Int") && opType != checker.findType("Float")) {
		checker.typeError("The '-' operator can only be applied to values/variables of type 'Int' or 'Float'.");
	}
}

EXPR *ExprFindCommensurate( EXPR *expr )
    {
    unsigned int i, j ;
    EXPR *tmp, *tmp2 ;

    for( i = 0 ; i < U(UnitList)->used ; i++ )
	{
	if( U(UN(i))->used != U(expr)->used )
	    continue ;
	for( j = 1 ; j < U(expr)->used ; j++ )
	    {
	    if( !BooleanValue( (BOOL*) OP3( "?=", U(UN(i))->list[j], U(expr)->list[j] ) ) )
		break ;
	    }
	if( j == U(expr)->used )			/* found one */
	    {
	    tmp = OP3( "/", U(expr)->list[0], U(UN(i))->list[0] ) ;
	    tmp2 = Real( MAGNITUDE( tmp ), i ) ;
	    delete tmp ;
	    delete expr ;
	    return tmp2 ;
	    }
	}

    for( i = 1 ; i < U(expr)->used ; i++ )
	{
	if( IS_ZERO( U(expr)->list[i] ) )
	    continue ;
	if( MAGNITUDE( U(expr)->list[i] ) == 1.0 )
	    tmp = U(UN(i))->Ehead->Copy() ;
	else
	    {
	    tmp = Operator( OPER_POW ) ;
	    D(tmp)->Eleft = U(UN(i))->Ehead->Copy() ;
	    D(tmp)->Eright = U(expr)->list[i]->Copy() ;
	    }
	if( U(expr)->Eeval )
	    {
	    tmp2 = Operator( OPER_MULTIPLY ) ;
	    D(tmp2)->Eleft = U(expr)->Eeval ;
	    D(tmp2)->Eright = tmp ;
	    U(expr)->Eeval = tmp2 ;
	    }
	else
	    U(expr)->Eeval = tmp ;
	}

    tmp = Real( MAGNITUDE( U(expr)->list[0] ), U(UnitList)->used ) ;
    delete U(expr)->list[0] ;
    U(expr)->list[0] = Real(1,0) ;
    ListAppend( UnitList, expr ) ;
    return tmp ;
    }

        std::pair<MPI_Request, const K*>* buildTwo(Prcndtnr* B, const MPI_Comm& comm) {
            static_assert(std::is_same<typename Prcndtnr::super&, decltype(*this)>::value || std::is_same<typename Prcndtnr::super::super&, decltype(*this)>::value, "Wrong preconditioner");
            std::pair<MPI_Request, const K*>* ret = nullptr;
            constexpr unsigned short N = std::is_same<typename Prcndtnr::super&, decltype(*this)>::value ? 2 : 3;
            unsigned short allUniform[N + 1];
            allUniform[0] = Subdomain<K>::_map.size();
            const Option& opt = *Option::get();
            unsigned short nu = allUniform[1] = (_co ? _co->getLocal() : static_cast<unsigned short>(opt["geneo_nu"]));
            allUniform[2] = static_cast<unsigned short>(~nu);
            if(N == 3)
                allUniform[3] = nu > 0 ? nu : std::numeric_limits<unsigned short>::max();
            {
                MPI_Op op;
#ifdef __MINGW32__
                MPI_Op_create(&f<N>, 1, &op);
#else
                auto f = [](void* in, void* inout, int*, MPI_Datatype*) -> void {
                    HPDDM_LAMBDA_F(in, input, inout, output, N)
                };
                MPI_Op_create(f, 1, &op);
#endif
                MPI_Allreduce(MPI_IN_PLACE, allUniform, N + 1, MPI_UNSIGNED_SHORT, op, comm);
                MPI_Op_free(&op);
            }
            if(nu > 0 || allUniform[1] != 0 || allUniform[2] != std::numeric_limits<unsigned short>::max()) {
                if(!_co) {
                    _co = new CoarseOperator;
                    _co->setLocal(nu);
                }
                double construction = MPI_Wtime();
                if(allUniform[1] == nu && allUniform[2] == static_cast<unsigned short>(~nu))
                    ret = _co->template construction<1, excluded>(Operator(*B, allUniform[0]), comm);
                else if(N == 3 && allUniform[1] == 0 && allUniform[2] == static_cast<unsigned short>(~allUniform[3]))
                    ret = _co->template construction<2, excluded>(Operator(*B, allUniform[0]), comm);
                else
                    ret = _co->template construction<0, excluded>(Operator(*B, allUniform[0]), comm);
                construction = MPI_Wtime() - construction;
                if(_co->getRank() == 0 && opt.val<int>("verbosity") > 0) {
                    std::stringstream ss;
                    ss << std::setprecision(2) << construction;
                    std::string line = " --- coarse operator transferred and factorized by " + to_string(static_cast<int>(opt["master_p"])) + " process" + (static_cast<int>(opt["master_p"]) == 1 ? "" : "es") + " (in " + ss.str() + "s)";
                    std::cout << line << std::endl;
                    std::cout << std::right << std::setw(line.size()) << "(criterion = " + to_string(allUniform[1] == nu && allUniform[2] == static_cast<unsigned short>(~nu) ? nu : (N == 3 && allUniform[2] == static_cast<unsigned short>(~allUniform[3]) ? -_co->getLocal() : 0)) + " -- topology = " + to_string(static_cast<int>(opt["master_topology"])) + " -- distribution = " + to_string(static_cast<int>(opt["master_distribution"])) + ")" << std::endl;
                    std::cout.unsetf(std::ios_base::adjustfield);
                }
            }
            else {
                delete _co;
                _co = nullptr;
            }
            return ret;
        }

main() {
	int k, n, a, b;
	for(a = 0; a < 10002; a++)	LOW[a] = a & (-a);
	scanf("%d", &k);
	while(k--) {
		scanf("%d", &n);
		for(a = 0; a < n; a++)
			scanf("%d %d %d", &A[a].a, &A[a].b, &A[a].c), 
			B[a].a = A[a].b, B[a].b = A[a].a, B[a].c = A[a].c;
		MergeSort(0, n-1, A), MergeSort(0, n-1, B);
		int Pa, Pb, Pc, t, Ans = 0;
		for(a = 0; a < n; ) {
			Pa = A[a].a;
			while(a < n && A[a].a <= Pa)	a++;
			memset(C, 0, (10000-Pa+2)*4);
			for(b = 0; b < n && Pa+B[b].a <= 10000; ) {
				Pb = B[b].a, Pc = 10000-Pa-Pb+1;
				while(b < n && B[b].a <= Pb) {
					if(B[b].b <= Pa)	Modify(B[b].c+1, Pc);
					b++;
				}
				t = Operator(Pc);
				Ans = Ans > t ? Ans : t;
			}
		}
		printf("%d\n", Ans);
	}
	return 0;
}

//599 funcitons
void Autonomous599()
{
  while(true)
  {

    if((SensorValue[kill_sw] < 127)&& ENABLE_KILL_SWITCH) //kill button on robot is A/D port to save digital ports
    {

      if(script != no_script) // stop scripts by reinitializing
      {
        Initialize();
        bsingle_step_mode = false;
      }

      allMotorsOff();
      break;
    }
    Process_sensors(); // read and process sensors to get variables needed for functions

    Operator(); // read driver commands from joystick which are not under script control

    Select_autonomous_script();//call autonomous script based upon cortex input auto_select (in8) port status

    Run_scripts();// Runs the selected script from Select_autonomous_script() to get commnads from scripts

    //call core functions here that use commands from operator() and run_scripts() functions

    Core_functions();



  }//end while
}

    void work(void)
    {
        //number of elements to work with
        auto elems = this->workInfo().minElements;
        if (elems == 0) return;

        //access to input ports and output port
        const std::vector<Pothos::InputPort *> &inputs = this->inputs();
        Pothos::OutputPort *output = this->output(0);

        //establish pointers to buffers
        auto out = Pothos::BufferChunk(output->buffer()).as<Type *>();
        auto in0 = inputs[0]->buffer().as<const Type *>();
        if (out == in0) _numInlineBuffers++; //track buffer inlining

        //loop through available ports
        for (size_t i = 1; i < inputs.size(); i++)
        {
            auto *inX = inputs[i]->buffer().as<const Type *>();
            Operator(in0, inX, out, elems*output->dtype().dimension());
            in0 = out; //operate on output array next loop
            inputs[i]->consume(elems); //consume on ith input port
        }

        //produce and consume on 0th ports
        inputs[0]->consume(elems);
        output->produce(elems);
    }

AttributePtr gen_text(const RuleTable& print_rules, NodePtr root,
      BindingsPtr bindings) {
   const Rules& rules(bindings->get_rules());
   std::ostringstream os;
   if (rules.operator_rules_defined()) {
      NodePtr cloned_root = clone_including_attributes(root);
      /*
	 the parentheses operator can be configured through
	 the operator set named "parentheses";
	 Op::LPAREN is taken by default
      */
      OperatorSetPtr parenthesesSet = rules.get_opset("parentheses");
      Operator parentheses;
      if (parenthesesSet && parenthesesSet->get_card() == 1) {
	 OperatorSet::Iterator it = parenthesesSet->begin();
	 parentheses = Operator(*it);
      } else {
	 parentheses = Op::LPAREN;
      }
      parenthesize(cloned_root, rules.get_operator_table(), parentheses);
      root = cloned_root;
   }
   if (print(os, root, print_rules, bindings)) {
      return std::make_shared<Attribute>(os.str());
   } else {
      return AttributePtr(nullptr);
   }
}

 void GroupStart() override
 {
   FlushOperations();
   Ops.push(Operator(GROUP_START));
   Delegate.GroupStart();
   LastIsMatch = false;
 }

 void Operation(const std::string& op) override
 {
   const std::size_t usedVals = Operator(op).Parameters();
   CheckAvailableParameters(usedVals, Position);
   Position = Position - usedVals + 1;
   Delegate.Operation(op);
 }

//===--------------------------------------------------------------------===//
// PhysicalSortGroupBy
//===--------------------------------------------------------------------===//
Operator PhysicalSortGroupBy::make(
    std::vector<std::shared_ptr<expression::AbstractExpression>> columns,
    std::vector<AnnotatedExpression> having) {
  PhysicalSortGroupBy *agg = new PhysicalSortGroupBy;
  agg->columns = std::move(columns);
  agg->having = move(having);
  return Operator(agg);
}

//===--------------------------------------------------------------------===//
// Get
//===--------------------------------------------------------------------===//
Operator LogicalGet::make(storage::DataTable *table,
                          std::vector<Column *> cols)
{
  LogicalGet *get = new LogicalGet;
  get->table = table;
  get->columns = cols;
  return Operator(get);
}

Type
compile(const Node&  l, const UnaryOperator&   op, Context&  ctx)
{
  auto  l_type = l.compile(ctx);

    if(op == Operator('&'))
    {
        if(l_type != TypeKind::reference)
        {
          printf("参照でないオブジェクトのアドレスを取得しようとしました\n");

          throw;
        }


      return I32Type();
    }


    if(l_type == TypeKind::reference)
    {
      l_type = l_type.compile_dereference(ctx);
    }


    switch(op)
    {
      case(Operator('*')):
          if(l_type != TypeKind::pointer)
          {
            printf("ポインタでないオブジェクトを参照しようとしました\n");

            throw;
          }


        return l_type.make_reference();
        break;
      case(Operator('!')): ctx.push("  lnot;\n");break;
      case(Operator('~')): ctx.push("  bnot;\n");break;
      case(Operator('-')): ctx.push("  neg ;\n");break;
    }


  return I32Type();
}

void Operator::Register(uint16_t opcode, bool (*o)(const Context &, uint16_t &index))
{
    if (Operators[opcode]._operator) {
        Operators[opcode].setOverload(o);
    } else {
        Operators[opcode] = Operator(o);
    }
}

//===--------------------------------------------------------------------===//
// PhysicalUpdate
//===--------------------------------------------------------------------===//
Operator PhysicalUpdate::make(
    std::shared_ptr<catalog::TableCatalogObject> target_table,
    const std::vector<std::unique_ptr<peloton::parser::UpdateClause>> *
        updates) {
  PhysicalUpdate *update = new PhysicalUpdate;
  update->target_table = target_table;
  update->updates = updates;
  return Operator(update);
}

void PostOrder(BTree *tree)
{
    if(tree==NULL)
        return;
    if(tree->lchild!=NULL)
        PostOrder(tree->lchild);
    if(tree->rchild!=NULL)
        PostOrder(tree->rchild);
    Operator(tree->data);
}