bool SimpleUnaryOperation::keyPressedOnPosition(Position const& _p, KeyEvent const* _e)
{
if (!_p.exists())
return false;
bool pre;
if (!Operator(_e->text(), Operator::UnaryPrefix).isNull() && (_p->isPlaceholder()/* || _e->isInserting()*/))
pre = true;
else if (!Operator(_e->text(), Operator::UnaryPostfix).isNull() && (!Operator(_e->text(), Operator::UnaryPrefix).isNull() || !_p->isPlaceholder()))
pre = false;
else
return false;
Operator o(_e->text(), pre ? Operator::UnaryPrefix : Operator::UnaryPostfix);
Position p = slideOnPrecedence(_p, o.precedence(), o.associativity(), _e->nearestBracket(_p));
bool b = findOperators(o, p->isKind<Typed>() ? p->asKind<Typed>()->apparentType() : Type()).size();
if (b && !isTemporary(p.concept()))
{
SimpleUnaryOperation* n = new SimpleUnaryOperation(o, p->isKind<Typed>() ? p->asKind<Typed>()->apparentType() : Type());
_e->noteStrobeCreation(n, &*p);
p->insert(n, TheOperand);
n->validifyChildren();
_e->codeScene()->dropCursor(n);
return true;
}
return false;
}
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 UnaryOpExpressionAST::generateCode(CodeGenerator& codeGen, GeneratedFunction& func) {
if (mOp == Operator('-')) {
auto opType = mOperand->expressionType(codeGen.typeChecker());
if (*opType == *codeGen.typeChecker().findType("Int")) {
func.addInstruction("LDINT 0");
} else if (*opType == *codeGen.typeChecker().findType("Float")) {
func.addInstruction("LDFLOAT 0");
}
mOperand->generateCode(codeGen, func);
func.addInstruction("SUB");
} else if (mOp == Operator('!')) {
mOperand->generateCode(codeGen, func);
func.addInstruction("NOT");
}
}
//===--------------------------------------------------------------------===//
// Scan
//===--------------------------------------------------------------------===//
Operator PhysicalScan::make(storage::DataTable *table,
std::vector<Column *> cols)
{
PhysicalScan *scan = new PhysicalScan;
scan->table = table;
scan->columns = cols;
return Operator(scan);
}
Operator LogicalAggregateAndGroupBy::make(
std::vector<std::shared_ptr<expression::AbstractExpression>> &columns,
std::vector<AnnotatedExpression> &having) {
LogicalAggregateAndGroupBy *group_by = new LogicalAggregateAndGroupBy;
group_by->columns = move(columns);
group_by->having = move(having);
return Operator(group_by);
}
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);
}
//===--------------------------------------------------------------------===//
// InnerHashJoin
//===--------------------------------------------------------------------===//
Operator PhysicalInnerHashJoin::make(
std::vector<AnnotatedExpression> conditions,
std::vector<std::unique_ptr<expression::AbstractExpression>>& left_keys,
std::vector<std::unique_ptr<expression::AbstractExpression>>& right_keys) {
PhysicalInnerHashJoin *join = new PhysicalInnerHashJoin();
join->join_predicates = std::move(conditions);
join->left_keys = std::move(left_keys);
join->right_keys = std::move(right_keys);
return Operator(join);
}
//===--------------------------------------------------------------------===//
// PhysicalInsert
//===--------------------------------------------------------------------===//
Operator PhysicalInsert::make(
std::shared_ptr<catalog::TableCatalogObject> target_table, const std::vector<std::string> *columns,
const std::vector<std::vector<
std::unique_ptr<peloton::expression::AbstractExpression>>> *values) {
PhysicalInsert *insert_op = new PhysicalInsert;
insert_op->target_table = target_table;
insert_op->columns = columns;
insert_op->values = values;
return Operator(insert_op);
}
//===--------------------------------------------------------------------===//
// Query derived get
//===--------------------------------------------------------------------===//
Operator LogicalQueryDerivedGet::make(
oid_t get_id, std::string &alias,
std::unordered_map<std::string,
std::shared_ptr<expression::AbstractExpression>>
alias_to_expr_map) {
LogicalQueryDerivedGet *get = new LogicalQueryDerivedGet;
get->table_alias = alias;
get->alias_to_expr_map = alias_to_expr_map;
get->get_id = get_id;
return Operator(get);
}
//===--------------------------------------------------------------------===//
// Query derived get
//===--------------------------------------------------------------------===//
Operator QueryDerivedScan::make(
oid_t get_id, std::string alias,
std::unordered_map<std::string,
std::shared_ptr<expression::AbstractExpression>>
alias_to_expr_map) {
QueryDerivedScan *get = new QueryDerivedScan;
get->table_alias = alias;
get->alias_to_expr_map = alias_to_expr_map;
get->get_id = get_id;
return Operator(get);
}
/**
* Constructor for a leaf (number) node
*/
Expression::Expression(Number num)
{
// Initilize the pointers to null
this->left = nullptr;
this->right = nullptr;
// Initilize the operation to the null operatoon
this->op = Operator();
// Initlize the number to num
this->num = num;
}
//This function responds to the user commands
void Scheduler::Invoke(String binaryInput)
{
Tokenize(binaryInput);
if(elevatorID==3) //special code for toggling userType (shortage of input pins)
return;
if(userType == "Operator")
{Operator();return;}
else
{Passenger();return;}
}
std::shared_ptr<Type> BinaryOpExpressionAST::expressionType(const TypeChecker& checker) const {
auto& boolTypes = checker.operators().binaryOpReturnTypes();
if (boolTypes.count(mOp) > 0) {
return boolTypes.at(mOp);
} else {
if (mOp == Operator('=')) {
return checker.findType("Void");
} else {
return mLeftHandSide->expressionType(checker);
}
}
}
//===--------------------------------------------------------------------===//
// Get
//===--------------------------------------------------------------------===//
Operator LogicalGet::make(oid_t get_id,
std::vector<AnnotatedExpression> predicates,
std::shared_ptr<catalog::TableCatalogObject> table, std::string alias,
bool update) {
LogicalGet *get = new LogicalGet;
get->table = table;
get->table_alias = alias;
get->predicates = std::move(predicates);
get->is_for_update = update;
get->get_id = get_id;
util::to_lower_string(get->table_alias);
return Operator(get);
}
BOOL CCalculator::Expression(CCalcExpression** ppcExpression)
{
BOOL bOperator;
BOOL bOperand;
BOOL bFirst;
CArrayIntAndPointer cArray;
CCalcOperator* pcOperator;
CCalcExpression* pcOperand;
cArray.Init(16);
bFirst = TRUE;
for (;;)
{
for (;;)
{
bOperator = Operator(&pcOperator);
if (!bOperator)
{
break;
}
cArray.Add(pcOperator, 0);
}
bOperand = Operand(&pcOperand);
if (!bOperand && !bOperator)
{
if (bFirst)
{
cArray.Kill();
return FALSE;
}
else
{
BuildExpression(ppcExpression, &cArray);
cArray.Kill();
if (*ppcExpression == NULL)
{
return FALSE;
}
else
{
return TRUE;
}
}
}
cArray.Add(pcOperand, 0);
bFirst = FALSE;
}
}
main() {
int N, Q, v, L, R, i;
int a, b;
for(a = 1; a <= 200000; a++)
lb[a] = a & -a;
scanf("%d %d", &N, &Q);
while(Q--) {
v = Input();
if(v == 1) {
i = Input();
if(A[i] == 0) Modify(i, 1);
else Modify(i, -1);
}
else {
L = Input(), R = Input();
b = Operator(R) - Operator(L-1);
if(b&1) puts("1");
else puts("0");
}
}
return 0;
}
//===--------------------------------------------------------------------===//
// SeqScan
//===--------------------------------------------------------------------===//
Operator PhysicalSeqScan::make(oid_t get_id, std::shared_ptr<catalog::TableCatalogObject> table,
std::string alias,
std::vector<AnnotatedExpression> predicates,
bool update) {
assert(table != nullptr);
PhysicalSeqScan *scan = new PhysicalSeqScan;
scan->table_ = table;
scan->table_alias = alias;
scan->predicates = std::move(predicates);
scan->is_for_update = update;
scan->get_id = get_id;
return Operator(scan);
}
