예제 #1
0
int main()
{
    scanf("%d",&N);
    for (int i=1;i<=N;++i)
    {
        scanf("%d",&Val(i));
        Sum(i)=Ms(i)=Lms(i)=Rms(i)=Val(i);
        Par(i)=i-1,Rch(i-1)=i,Size(i)=N-i+1;
        splay(root,i);
    }
    splay(root,1),Par(N+1)=1,Lch(1)=N+1,Size(N+1)=1,splay(root,N+1);
    splay(root,N),Par(N+2)=N,Rch(N)=N+2,Size(N+2)=1,splay(root,N+2);
    tot=N+2;
    for (scanf("%d",&Que);Que--;)
    {
        scanf("%s%d",cmd,&x);
        if (cmd[0]=='D')    D(Findkth(root,x+1));
        else
        {
            scanf("%d",&y);
            if (cmd[0]=='Q')    Q(Findkth(root,x),Findkth(root,y+2));
            else
            if (cmd[0]=='I')    I(Findkth(root,x+1),y);
            else    R(Findkth(root,x+1),y);
        }
    }
	print_r(root); printf("\n");
	print_l(root); printf("\n");
    return 0;
}
예제 #2
0
TEST(TNEANet, AddEdgeAttributeError) {
  PNEANet Graph;
  Graph = TNEANet::New();

  TStr StrAttr("name");
  TStr FltAttr("weight");
  TStr IntAttr("test");

  Graph->AddStrAttrE(StrAttr);
  Graph->AddFltAttrE(FltAttr);
  Graph->AddIntAttrE(IntAttr);
  int NumEdges = 5;
  for (int i = 0; i < NumEdges + 1; i++) {
    Graph->AddNode(i);
  }
  for (int i = 0; i < NumEdges; i++) {
    Graph->AddEdge(i, i+1, i);
    Graph->AddIntAttrDatE(i, TInt(i), IntAttr);
    Graph->AddFltAttrDatE(i, TFlt(i), FltAttr);
    TInt Val(i);
    Graph->AddStrAttrDatE(i, Val.GetStr(), StrAttr);
  }
  Graph->DelNode(0);
  for (int j = 1; j < NumEdges; j++) {
    ASSERT_EQ(Graph->GetIntAttrDatE(j, IntAttr), TInt(j));
    ASSERT_EQ(Graph->GetFltAttrDatE(j, FltAttr), TFlt(j));
    TInt Val(j);
    ASSERT_EQ(Graph->GetStrAttrDatE(j, StrAttr), Val.GetStr());
  }
}
예제 #3
0
파일: ast.cpp 프로젝트: strelec/MemoryBeast
	AST(Json::Value& expr, Table *t) {
		op = VAL;
		val = Val();

		switch(expr.type()) {
			case Json::arrayValue: {
				string call = expr[0].asString();
				if (call == "get") {
					path p;
					for(u32 i=1; i<expr.size(); ++i)
						p.push_back( expr[i].asString() );

					forn = t->findColumn(p);
					if (forn.size() == 1) {
						op = GET;
						get = forn.front();
					} else if (forn.size() != 0) {
						op = FORN;
						for(auto &c: forn)
							if(c->type == Type::MFORN)
								op = MFORN;
					}
				} else {
					if (!determineFunc(call))
						throw UnknownOperationE(call);
					for(u32 i=1; i<expr.size(); ++i)
						params.push_back(AST(expr[i], t));
				}
			} break;
			case Json::objectValue:
				throw HashExpressionE();
			break; default:
				val = Val(expr);
		}
	}
예제 #4
0
파일: json.cpp 프로젝트: urdvr/vabamorf
void CJSONWriter::Val(const CFSVar &Var) {
	switch (Var.GetType()) {
		case CFSVar::VAR_EMPTY:
			NullVal();
		break;
		case CFSVar::VAR_INT:
			IntVal(Var.GetInt());
		break;
		case CFSVar::VAR_FLOAT:
			FloatVal(Var.GetFloat());
		break;
		case CFSVar::VAR_BOOL:
			BoolVal(Var.GetBool());
		break;
		case CFSVar::VAR_STRING:
			StringVal(Var.GetAString());
		break;
		case CFSVar::VAR_MAP:
			ObjectStart();
			for (INTPTR ip=0; ip<Var.GetSize(); ip++) {
				CFSAString szKey=Var.GetKey(ip);
				Key(szKey);
				Val(Var[szKey]);
			}
			ObjectEnd();
		break;
		case CFSVar::VAR_ARRAY:
			ArrayStart();
			for (INTPTR ip=0; ip<Var.GetSize(); ip++) {
				Val(Var[ip]);
			}
			ArrayEnd();
		break;
	}
}
예제 #5
0
//13.<分支语句>—> if  <布尔表达式> then  <语句> 
//| if  <布尔表达式> then  <语句> else <语句>
void switchStatement(){
	if (lookahead == IF){
		match(IF);
		TFexit tf = booleaexpression();//真假出口
		match(THEN);
		//填真出口
		BackPatch(tf.TC, sno);

		statementlists();
		
		if (lookahead == ELSE){
			// 1 无条件跳转
			int j = sno;
			quadruples.push_back(Quadruple(sno++, 0,Val(),Val()));
			match(ELSE);
			//回填假出口
			BackPatch(tf.FC, sno);
			statementlists();
			//回填 1 无条件跳转
			BackPatch(j, sno);
		}
		else {
			// 回填假出口
			BackPatch(tf.FC, sno);
		}
	}
	else{
		error(24);
	}
 }
예제 #6
0
//19. <关系表达式>—> <表达式> <关系> <表达式>
TFexit relationexpression(){
	Val v1 = expression();
	int re = relation();
	Val v2 = expression();
	quadruples.push_back(Quadruple(sno++, re, v1, v2));
	quadruples.push_back(Quadruple(sno++,0,Val(),Val()));//无条件跳转op=0
	return TFexit(sno - 2, sno - 1);
}
예제 #7
0
inline void Tupdate(int x)
{
    Size(x)=Size(Lch(x))+1+Size(Rch(x));
    Sum(x)=Sum(Lch(x))+Val(x)+Sum(Rch(x));
    Lms(x)=max(Lms(Lch(x)),Sum(Lch(x))+Val(x)+Lms(Rch(x)));
    Rms(x)=max(Rms(Rch(x)),Rms(Lch(x))+Val(x)+Sum(Rch(x)));
    Ms(x)=Rms(Lch(x))+Val(x)+Lms(Rch(x));
    if (Lch(x))    Ms(x)=max(Ms(x),Ms(Lch(x)));
    if (Rch(x))    Ms(x)=max(Ms(x),Ms(Rch(x)));
}
예제 #8
0
//14.<循环语句>—> while  <布尔表达式> do <语句>
void loopStatement(){
	match(WHILE);
	//int boolId = 序号全局变量
	int boolId = sno;
	TFexit tf = booleaexpression();//真假出口

	match(DO);
	//回填真出口
	BackPatch(tf.TC, sno);

	statementlists();
	//(j boolId)
	quadruples.push_back(Quadruple(sno++, 0, Val(), Val(), boolId));
	//回填假出口
	BackPatch(tf.FC, sno);
}
예제 #9
0
파일: packed4.C 프로젝트: 0day-ci/gcc
int Foo (Packed &p, int i, int ui)
{
  int r;
  
  if ((r = Val (p.i, i)))
    return r;
  if ((r = Val (p.u.i, ui)))
    return r + 2;
  if ((r = Val (p.u, ui)))
    return r + 4;
  
  if ((r = ConstRef (p.i, &p.i, i)))
    return r + 6;

  return 0;
}
예제 #10
0
TEST(TNEANet, AddSAttrDatN_str) {
  PNEANet Graph;
  Graph = TNEANet::New();
  Graph->AddNode(0);
  TStr Val("5");
  TInt Id(0);
  int status = Graph->AddSAttrDatN(Id, 1, Val);
  EXPECT_EQ(-1, status);
  TInt AttrId;
  TStr AttrName("TestFlt");
  Graph->AddSAttrN(AttrName, atStr, AttrId);
  TInt ErrorVal(1);
  status = Graph->AddSAttrDatN(Id, AttrId, ErrorVal);
  EXPECT_EQ(-2, status);
  status = Graph->AddSAttrDatN(Id, AttrId, Val);
  EXPECT_EQ(0, status);
  status = Graph->AddSAttrDatN(Id, AttrName, Val);
  EXPECT_EQ(0, status);
  TStr NewName("TestStr2");
  status = Graph->AddSAttrDatN(Id, NewName, Val);
  EXPECT_EQ(0, status);
  TInt ErrorId(1);
  status = Graph->AddSAttrDatN(ErrorId, AttrId, Val);
  EXPECT_EQ(-1, status);
}
예제 #11
0
//10.<赋值语句>—> id  =  <表达式> ;
void assignment(){
	char varname[MAXIDLEN];
	strcpy(varname, token);
	Val v2 = Val(1, GetIdByName(varname));

	match(id);
	if (!isexist(varname)){
		strcpy(token, varname);
		error(46);
	}
	
	match(equl);
	Val v = expression();

	match(semicolon);

	quadruples.push_back(Quadruple(sno++, equl, v, v2));
	//生成四元式
	/*printf("%3d (=,", sno++);
	if (v.type == 1) printf("%s", GetNameByID(v.value1));
	else if (v.type == 0) printf("%d", v.value1);
	else if (v.type == 2) printf("%lf", v.value2);
	else printf("t%d", v.value1);
	printf(",%s)\n", varname);*/
}
예제 #12
0
TEST(TNEANet, AddSAttrDatE_flt) {
  PNEANet Graph;
  Graph = TNEANet::New();
  Graph->AddNode(0);
  Graph->AddNode(1);
  Graph->AddEdge(0, 1, 0);
  TFlt Val(5.0);
  TInt Id(0);
  int status = Graph->AddSAttrDatE(Id, 1, Val);
  EXPECT_EQ(-1, status);
  TInt AttrId;
  TStr AttrName("TestFlt");
  Graph->AddSAttrE(AttrName, atFlt, AttrId);
  TInt ErrorVal(1);
  status = Graph->AddSAttrDatE(Id, AttrId, ErrorVal);
  EXPECT_EQ(-2, status);
  status = Graph->AddSAttrDatE(Id, AttrId, Val);
  EXPECT_EQ(0, status);
  status = Graph->AddSAttrDatE(Id, AttrName, Val);
  EXPECT_EQ(0, status);
  TStr NewName("TestFlt2");
  status = Graph->AddSAttrDatE(Id, NewName, Val);
  EXPECT_EQ(0, status);
  TInt ErrorId(1);
  status = Graph->AddSAttrDatE(ErrorId, AttrId, Val);
  EXPECT_EQ(-1, status);
}
예제 #13
0
va_dcl
#else

Symbol_t* Symbol(Msg_t msg, ...)
#endif
{
    char	blank[64];
    String_t*	image;
    size_t	indent;
    Symbol_t*	obj;
    va_init(ap, msg, obj);
    if (!obj) return NULL;

    switch (msg) {
    case _Init:
	return (Symbol_t*) Obj(_Init, obj, Symbol);

    case _Image:
        image  = va_arg(ap, String_t*);
        if ((indent = va_arg(ap, size_t)) >= sizeof(blank))
	    return NULL;

        if (indent > 0) memset(blank, ' ', indent);
	blank[indent] = 0;

        return (Symbol_t*) String(_Cat, image, blank, "'", Val(obj), "'", 0);

    default:
        return (Symbol_t*) String(_Relay, msg, obj, ap);
    }
}
예제 #14
0
파일: lru.hpp 프로젝트: jimmy-kuo/websearch
typename LRUCacheH4<K, V>::Val * LRUCacheH4<K, V>::_insert(const K & key)
{
	// if we have grown too large, remove LRU
	if (_map.size() >= _maxsize) {
		Val * old_lru = _lru;
		if (_lru->second._newer) {
			_lru = _lru->second._newer;
			_lru->second._older = NULL;
		}
		// erase takes a 'const K &', if we don't make a copy of the key,
		// it'll be destroied in erase, but the reference may be used
		// later in erase
		//const K k = old_lru->first;
		//cerr << "_map.erase, key=" << k << endl;
		//_map.erase(k);
		_map.erase(old_lru->first);
	}
	
	// insert key to MRU position
	std::pair<typename MAP_TYPE::iterator, bool> ret
		= _map.insert(Val(key, LRUCacheH4Value<K, V>(V(), _mru, NULL)));
	Val * inserted = &*ret.first;
	if (_mru)
		_mru->second._newer = inserted;
	_mru = inserted;
	
	// possibly update the LRU
	if (!_lru)
		_lru = _mru;
	else if (!_lru->second._newer)
		_lru->second._newer = _mru;
	
	return inserted;
}
예제 #15
0
파일: array.cpp 프로젝트: gravmath/Projects
//******************************************************************************
//Name:  array print                                                           *
//                                                                             *
//Purpose:  prints out the value of the array given the indices                *
//                                                                             *
//Takes: a message string and variable list of indices                         *
//******************************************************************************
void array::print(const char *msg, int range1, ...) const
{
  int *range, i;

//Allocate space for the range array
  range = new int[p->num_indices];

//Initialize the variable argument list
  va_list arg_list;

  va_start(arg_list,range1);

//Pack the range array
  range[0] = range1;
  for(i = 1; i < p->num_indices; i++)
	  range[i] = va_arg(arg_list,int);

  double value;

  value = Val(range);

  if(*msg) cout << msg;

  cout << setw(6) << setprecision(3) << value;

//Clean up
  va_end(arg_list);
  delete [] range;
}
예제 #16
0
 void init(const Key &null_value=Key(),std::size_t cache_size=10000) 
 {
     cachesize=next_doubled_prime(cache_size);
     cache.clear();
     cache.resize(cachesize,entry(null_value,Val()));
     assert(cache.size()==cachesize);
     n_miss=n_hit=0;
 }    
예제 #17
0
void JFrame::push(jtype jt)
{
    assert(m_top<(int)max_size());
    if (jt < i32) {
        jt = i32;
    }
    switch (jt) {
    case i8:
    case i16:
    case u16:
    case i32:
    case jobj:
        m_stack[++m_top] = Val(jt);
        break;
    case i64:
        m_stack[++m_top] = Val(jt);
        m_stack[++m_top] = Val(jt);
        break;
    case flt32:
        m_stack[++m_top] = Val(jt);
        break;
    case dbl64:
        m_stack[++m_top] = Val(jt);
        m_stack[++m_top] = Val(jt);
        break;
    default:
        assert( jt == jretAddr );
        m_stack[++m_top] = Val(jt);
        break;
    }
}
예제 #18
0
inline void I(int x,int y)
{
    splay(root,x);
    int v=Lch(x);
    for (;Rch(v);v=Rch(v));
    Rch(v)=++tot,Par(tot)=v,Size(tot)=1;
    Sum(tot)=Ms(tot)=Lms(tot)=Rms(tot)=Val(tot)=y;
    splay(root,tot);
}
예제 #19
0
파일: Value.hpp 프로젝트: Mike-Now/faif-MLR
 typename DomainEnumerate<Val>::ValueId
 DomainEnumerate<Val>::insert(const typename Val::Value& value) {
     Val attr(value, this);
     const_iterator found = std::find( values_.begin(), values_.end(), attr );
     if( found != values_.end() )
         return getValueId(found);
     //inserts element on the end (if not found)
     return getValueId( values_.insert( values_.end(), Val(value, this) ) );
 }
예제 #20
0
void print_r(int node)
{
	if(!node) { printf("()"); return; }
	printf("(");
	print_r( Lch(node) );
	printf(" %d ",Val(node));
	print_r( Rch(node) );
	printf(")");
}
예제 #21
0
void Compiler::gen_jsr(unsigned target)
{
    AR gr = valloc(jobj);
    const JInst& jinst = *m_curr_inst;
    movp(gr, jinst.next, m_bbinfo->start);
    vpush(Val(jretAddr, gr));
    gen_bb_leave(target);
    br(cond_none, target, m_bbinfo->start);
}
예제 #22
0
 ResolvedToken operator()(long long val)const
 {
     if( !m_EC.This.IsNull() )
     { //accessing table element. E.g.: table[0]
         Member Val((*m_EC.This)[val]);
         m_EC.This = NullReference();
         return boost::apply_visitor(*this,Val);
     }
     return val;
 }
예제 #23
0
TBool TfrLex::Eat( TLex& aLex, const TDesC& aTerm )
{
aLex.SkipSpace();
TLexMark unget;
aLex.Mark(unget);
if ( Val(aLex,aTerm) == KErrNone ) 
	return ETrue;
aLex.UnGetToMark(unget);
return EFalse;
}
예제 #24
0
 std::string operator()(long long val)const
 {
     if( !m_EC.This.IsNull() )
     { //accessing table element. E.g.: table[0]
         Member Val((*m_EC.This)[val]);
         m_EC.This = NullReference();
         return boost::apply_visitor(*this,Val);
     }
     return boost::lexical_cast<std::string>(val);
 }
예제 #25
0
void print_l(int node)
{
	if(!node) { printf("XX"); return; }
	printf(" %d ",Val(node));
	printf("(");
	print_l( Lch(node) );
	printf(",");
	print_l( Rch(node) );
	printf(")");
}
예제 #26
0
 // Return (true, value) if key exists and (false, Val()) otherwise.
 std::pair<bool, Val> Find(Key key) const{
   Node<Key, Val>* node = root_;
   while (node != NULL){
     if (key == node->key){
       return std::make_pair(true, node->val);
     } else if (Comp()(key, node->key)){
       node = node->left;
     } else {
       node = node->right;
     }
   }
   return std::make_pair(false, Val());
 }
예제 #27
0
파일: field.cpp 프로젝트: gravmath/Projects
//******************************************************************************
//Name:  GetTensor                                                             *
//                                                                             *
//Purpose:  get the tensor portion of the field given the position             *
//                                                                             *
//Takes: position stored as a tensor                                           *
//******************************************************************************
tensor  field::GetTensor(int *indices)
{
   tensor temp;
   int n, *r, new_n, *new_r;
   int i, j, dummy;

   //Get the total number of indices and ranges of the field
   n = NumIndices();
   r = Ranges();

   //Determine the number of indices on the temp tensor
   new_n = n  - 3;

   //Make a new array for resizing temp
   new_r = new int[new_n];

   //Pack the new_r array with the
   for( i = 0; i < new_n; i++ )
    {
      new_r[i] = r[i + 3];
    }

   //Resize the temp tensor
   temp.Resize(new_n, new_r);

   //Let the r array do double duty and pack the first three elements with the
   //values in the indices array
   for( i = 0; i < 3; i++) r[i] = indices[i];

   //now pack temp with the components of the tensor portion of the field
   for( i = 0; i < temp.p->product; i++)
	 {
      //Let the last indices of the r array hold the
      //index structure for the temp tensor
      dummy = 0;
      for( j = 0; j < new_n; j++)
       {
         r[j + 3] = (i - i%temp.p->scales[j] - dummy)/temp.p->scales[j];
         dummy += r[j + 3] * temp.p->scales[j];
       }

       temp.p->m[i] = Val(r);
    }

  //Clean up
  delete [] r;
  delete [] new_r;

  //Return the tensor
  return temp;
}
예제 #28
0
파일: array.cpp 프로젝트: gravmath/Projects
//******************************************************************************
//Name:  array print                                                           *
//                                                                             *
//Purpose:  prints out the values in the whole array without indices           *
//                                                                             *
//Takes:                                                                       *
//******************************************************************************
void array::print(char **buffer) const
{
  int *index, i, j, temp, num_indices, counter;

  //test for range = 1 indices
  num_indices = p->num_indices;
  for(i = 0; i < p->num_indices; i++)
  {
    if(p->range[i] == 1) num_indices--;
  }

  index  = new int[p->num_indices];
  if( *buffer != NULL ) delete [] *buffer;
  *buffer = new char[p->product*41 + 1];

  (*buffer)[0] = '\0';

  for(i = 0; i < p->product; i++)
   {
    //pack the index array testing for range = 1 cases
    temp = 0;
	 for(j = 0; j < num_indices - 1; j++)
     {
       index[j] = (i - i%p->scales[j] - temp)/p->scales[j];
       temp += index[j] * p->scales[j];
     }
    //range = 1 testing starts here
    if( num_indices < p->num_indices)
     {
       index[num_indices - 1] = (i - temp)/p->scales[num_indices - 1];
       for(j = num_indices; j < p->num_indices; j++) index[j] = 0;
     }
    else
     {
       index[j] = (i - temp)/p->scales[j];
     }

    //fill the buffer line
    counter = strlen(*buffer);
    sprintf((*buffer)+counter,"%g\n",Val(index));
   }

   //terminate the string properly
   counter = strlen(*buffer);
   (*buffer)[counter+1] = '\0';

   //clean-up
   delete [] index;

}
예제 #29
0
void CompilationEnvironment::load_env_var() {
    if ( String str = get_env( "METIL_INC_PATHS" ) ) {
        BasicVec<String> lst = tokenize( str, ';' );
        for( int i = 0; i < lst.size(); ++i )
            add_inc_path( lst[ i ] );
    }

    if ( String str = get_env( "METIL_LIB_PATHS" ) ) {
        BasicVec<String> lst = tokenize( str, ';' );
        for( int i = 0; i < lst.size(); ++i )
            add_lib_path( lst[ i ] );
    }

    if ( String str = get_env( "METIL_LIB_NAMES" ) ) {
        BasicVec<String> lst = tokenize( str, ';' );
        for( int i = 0; i < lst.size(); ++i )
            add_lib_name( lst[ i ] );
    }

    if ( String str = get_env( "METIL_PARSED" ) ) {
        BasicVec<String> lst = tokenize( str, ';' );
        for( int i = 0; i < lst.size(); ++i )
            parsed << lst[ i ];
    }

    if ( String str = get_env( "METIL_COMP_DIR"  ) ) _comp_dir = str;
    if ( String str = get_env( "METIL_CXX"       ) ) CXX       = str;
    if ( String str = get_env( "METIL_LD"        ) ) LD        = str;
    if ( String str = get_env( "METIL_NVCC"      ) ) NVCC      = str;
    if ( String str = get_env( "METIL_CPPFLAGS"  ) ) CPPFLAGS  = str;
    if ( String str = get_env( "METIL_LDFLAGS"   ) ) LDFLAGS   = str;
    if ( String str = get_env( "METIL_DEV_EMU"   ) ) device_emulation = Val( str );
    if ( String str = get_env( "METIL_REG_CNT"   ) ) maxrregcount = Val( str );
    if ( String str = get_env( "METIL_DBG_LEVEL" ) ) dbg_level = Val( str );
    if ( String str = get_env( "METIL_OPT_LEVEL" ) ) opt_level = Val( str );
    if ( String str = get_env( "METIL_CXX_NAME"  ) ) cxx_name  = str;
}
예제 #30
0
파일: APFloat.cpp 프로젝트: ahirOrg/ahir
void generate_f2i_tests(std::ostream &ofs
                        , const std::vector<llvm::APFloat> &x
                        , bool is_signed
                        , unsigned width) 
{
  for (unsigned i = 0, e = x.size(); i != e; ++i) {
    const llvm::APFloat &apf = x[i];
    bool ignored;
    uint64_t x[2];
    apf.convertToInteger(x, width, is_signed,
                         llvm::APFloat::rmTowardZero, &ignored);
    llvm::APInt Val(width, 2, x);
    ofs << get_padded_string(apf) << " " << get_padded_string(Val) << "\n";
  }
}