Esempio n. 1
0
bool PageInformation::ApplyStyle(PageInformation* pOther)
{
	APPLY2(m_iWidth);
	APPLY2(m_iHeight);
	APPLY2(m_iMarginLeft);
	APPLY2(m_iMarginRight);
	APPLY2(m_iMarginTop);
	APPLY2(m_iMarginBottom);
	APPLY2(m_iGutter);
	APPLY2(m_iHeaderY);
	APPLY2(m_iFooterY);
//	APPLY(m_iFirstPageNumber);
//	APPLY(m_iPageNumberXOffset);
//	APPLY(m_iPageNumberYOffset);
	APPLY(m_iTextFlow);
	m_bSwitchMarginDefs=pOther->m_bSwitchMarginDefs;
	m_bLandscape=pOther->m_bLandscape;
	m_titlePage = pOther->m_titlePage;
	m_bLeftToRightCols=pOther->m_bLeftToRightCols;
	m_bFacingPages = pOther->m_bFacingPages;


	m_Format=pOther->m_Format;
	m_HeadingAndPageSeparator=pOther->m_HeadingAndPageSeparator;
	m_Alignment=pOther->m_Alignment;
	m_iSectLinePitch = pOther->m_iSectLinePitch;

	return true;
}
Esempio n. 2
0
Move calcmove(Board *board,int player){
	if(board->b[0]==0&&board->b[1]==0){
		Move mv={player==ORDER?N*(N/2)+N/2:1,XX};
		return mv;
	}

	int score,best,bestp=-1,beststone=-1;
	for(int p=0;p<N*N;p++){
		if(!ISEMPTY(board->b[0]|board->b[1],p))continue;
		
		for(int stone=0;stone<2;stone++){
			score=0;
			Board b2=*board;
			APPLY(b2.b[stone],p);
			for(int i=0;i<MC_PLAYTHROUGHS;i++){
				score+=playthrough(b2,!player);
			}
			if(bestp==-1||(player==ORDER?score>best:score<best)){
				best=score;
				bestp=p;
				beststone=stone;
			}
		}
	}
	
	Move mv={bestp,beststone};
	return mv;
}
/*
 * Dump STUN message to a printable string output.
 */
PJ_DEF(char*) pj_stun_msg_dump(const pj_stun_msg *msg,
			       char *buffer,
			       unsigned length,
			       unsigned *printed_len)
{
    char *p, *end;
    int len;
    unsigned i;

    PJ_ASSERT_RETURN(msg && buffer && length, NULL);

    PJ_CHECK_STACK();
    
    p = buffer;
    end = buffer + length;

    len = pj_ansi_snprintf(p, end-p, "STUN %s %s\n",
			   pj_stun_get_method_name(msg->hdr.type),
			   pj_stun_get_class_name(msg->hdr.type));
    APPLY();

    len = pj_ansi_snprintf(p, end-p, 
			   " Hdr: length=%d, magic=%08x, tsx_id=%08x%08x%08x\n"
			   " Attributes:\n",
			   msg->hdr.length,
			   msg->hdr.magic,
			   *(pj_uint32_t*)&msg->hdr.tsx_id[0],
			   *(pj_uint32_t*)&msg->hdr.tsx_id[4],
			   *(pj_uint32_t*)&msg->hdr.tsx_id[8]);
    APPLY();

    for (i=0; i<msg->attr_count; ++i) {
	len = print_attr(p, (unsigned)(end-p), msg->attr[i]);
	APPLY();
    }

on_return:
    *p = '\0';
    if (printed_len)
	*printed_len = (unsigned)(p-buffer);
    return buffer;

#undef APPLY
}
void foo() {
  F(1.0, 3);
// CHECK-MESSAGES: :[[@LINE-1]]:3: warning: argument with implicit conversion from 'int' to 'double' followed by argument converted from 'double' to 'int', potentially swapped arguments.
// CHECK-FIXES: F(3, 1.0)

#define M(x, y) x##y()

  double b = 1.0;
  F(b, M(Some, Function));
// CHECK-MESSAGES: :[[@LINE-1]]:3: warning: argument with implicit conversion from 'int' to 'double' followed by argument converted from 'double' to 'int', potentially swapped arguments.
// CHECK-FIXES: F(M(Some, Function), b);

#define N F(b, SomeFunction())

  N;
// CHECK-MESSAGES: :[[@LINE-1]]:3: warning: argument with implicit conversion from 'int' to 'double' followed by argument converted from 'double' to 'int', potentially swapped arguments.
// In macro, don't emit fixits.
// CHECK-FIXES: #define N F(b, SomeFunction())

  G(b, 3);
  G(3, 1.0);
  G(0, 0);

  F(1.0, 1.0);    // no-warning
  F(3, 1.0);      // no-warning
  F(true, false); // no-warning
  F(0, 'c');      // no-warning

#define APPLY(f, x, y) f(x, y)
  APPLY(F, 1.0, 3);
// CHECK-MESSAGES: :[[@LINE-1]]:9: warning: argument with implicit conversion from 'int' to 'double' followed by argument converted from 'double' to 'int', potentially swapped arguments.
// CHECK-FIXES: APPLY(F, 3, 1.0);

#define PARAMS 1.0, 3
#define CALL(P) F(P)
  CALL(PARAMS);
// CHECK-MESSAGES: :[[@LINE-1]]:3: warning: argument with implicit conversion from 'int' to 'double' followed by argument converted from 'double' to 'int', potentially swapped arguments.  
// In macro, don't emit fixits.  
}
Esempio n. 5
0
static int playthrough(Board board,int player){
	(void)player;
	int win;
	Move poss[2*N*N];
	int nposs;
	while(true){
		win=checkwin(&board);
		if(win!=-1)return 1-2*win;

		nposs=0;
		for(int p=0;p<N*N;p++){
			for(int stone=0;stone<2;stone++){
				if(!ISEMPTY(board.b[0]|board.b[1],p))continue;
				poss[nposs].pos=p;
				poss[nposs++].stone=stone;
			}
		}
		assert(nposs>0); //else Chaos would've won

		int i=random()%nposs;
		APPLY(board.b[poss[i].stone],poss[i].pos);
	}
}
Esempio n. 6
0
malValuePtr EVAL(malValuePtr ast, malEnvPtr env)
{
    while (1) {
        const malList* list = DYNAMIC_CAST(malList, ast);
        if (!list || (list->count() == 0)) {
            return ast->eval(env);
        }

        // From here on down we are evaluating a non-empty list.
        // First handle the special forms.
        if (const malSymbol* symbol = DYNAMIC_CAST(malSymbol, list->item(0))) {
            String special = symbol->value();
            int argCount = list->count() - 1;

            if (special == "def!") {
                checkArgsIs("def!", 2, argCount);
                const malSymbol* id = VALUE_CAST(malSymbol, list->item(1));
                return env->set(id->value(), EVAL(list->item(2), env));
            }

            if (special == "do") {
                checkArgsAtLeast("do", 1, argCount);

                for (int i = 1; i < argCount; i++) {
                    EVAL(list->item(i), env);
                }
                ast = list->item(argCount);
                continue; // TCO
            }

            if (special == "fn*") {
                checkArgsIs("fn*", 2, argCount);

                const malSequence* bindings =
                    VALUE_CAST(malSequence, list->item(1));
                StringVec params;
                for (int i = 0; i < bindings->count(); i++) {
                    const malSymbol* sym =
                        VALUE_CAST(malSymbol, bindings->item(i));
                    params.push_back(sym->value());
                }

                return mal::lambda(params, list->item(2), env);
            }

            if (special == "if") {
                checkArgsBetween("if", 2, 3, argCount);

                bool isTrue = EVAL(list->item(1), env)->isTrue();
                if (!isTrue && (argCount == 2)) {
                    return mal::nilValue();
                }
                ast = list->item(isTrue ? 2 : 3);
                continue; // TCO
            }

            if (special == "let*") {
                checkArgsIs("let*", 2, argCount);
                const malSequence* bindings =
                    VALUE_CAST(malSequence, list->item(1));
                int count = checkArgsEven("let*", bindings->count());
                malEnvPtr inner(new malEnv(env));
                for (int i = 0; i < count; i += 2) {
                    const malSymbol* var =
                        VALUE_CAST(malSymbol, bindings->item(i));
                    inner->set(var->value(), EVAL(bindings->item(i+1), inner));
                }
                ast = list->item(2);
                env = inner;
                continue; // TCO
            }

            if (special == "quasiquote") {
                checkArgsIs("quasiquote", 1, argCount);
                ast = quasiquote(list->item(1));
                continue; // TCO
            }

            if (special == "quote") {
                checkArgsIs("quote", 1, argCount);
                return list->item(1);
            }
        }

        // Now we're left with the case of a regular list to be evaluated.
        std::unique_ptr<malValueVec> items(list->evalItems(env));
        malValuePtr op = items->at(0);
        if (const malLambda* lambda = DYNAMIC_CAST(malLambda, op)) {
            ast = lambda->getBody();
            env = lambda->makeEnv(items->begin()+1, items->end());
            continue; // TCO
        }
        else {
            return APPLY(op, items->begin()+1, items->end(), env);
        }
    }
}
Esempio n. 7
0
void applymove(Board *board,Move mv){
	APPLY(board->b[mv.stone],mv.pos);
}
Esempio n. 8
0
malValuePtr EVAL(malValuePtr ast, malEnvPtr env)
{
    if (!env) {
        env = replEnv;
    }
    while (1) {
        const malList* list = DYNAMIC_CAST(malList, ast);
        if (!list || (list->count() == 0)) {
            return ast->eval(env);
        }

        ast = macroExpand(ast, env);
        list = DYNAMIC_CAST(malList, ast);
        if (!list || (list->count() == 0)) {
            return ast->eval(env);
        }

        // From here on down we are evaluating a non-empty list.
        // First handle the special forms.
        if (const malSymbol* symbol = DYNAMIC_CAST(malSymbol, list->item(0))) {
            String special = symbol->value();
            int argCount = list->count() - 1;

            if (special == "def!") {
                checkArgsIs("def!", 2, argCount);
                const malSymbol* id = VALUE_CAST(malSymbol, list->item(1));
                return env->set(id->value(), EVAL(list->item(2), env));
            }

            if (special == "defmacro!") {
                checkArgsIs("defmacro!", 2, argCount);

                const malSymbol* id = VALUE_CAST(malSymbol, list->item(1));
                malValuePtr body = EVAL(list->item(2), env);
                const malLambda* lambda = VALUE_CAST(malLambda, body);
                return env->set(id->value(), mal::macro(*lambda));
            }

            if (special == "do") {
                checkArgsAtLeast("do", 1, argCount);

                for (int i = 1; i < argCount; i++) {
                    EVAL(list->item(i), env);
                }
                ast = list->item(argCount);
                continue; // TCO
            }

            if (special == "fn*") {
                checkArgsIs("fn*", 2, argCount);

                const malSequence* bindings =
                    VALUE_CAST(malSequence, list->item(1));
                StringVec params;
                for (int i = 0; i < bindings->count(); i++) {
                    const malSymbol* sym =
                        VALUE_CAST(malSymbol, bindings->item(i));
                    params.push_back(sym->value());
                }

                return mal::lambda(params, list->item(2), env);
            }

            if (special == "if") {
                checkArgsBetween("if", 2, 3, argCount);

                bool isTrue = EVAL(list->item(1), env)->isTrue();
                if (!isTrue && (argCount == 2)) {
                    return mal::nilValue();
                }
                ast = list->item(isTrue ? 2 : 3);
                continue; // TCO
            }

            if (special == "let*") {
                checkArgsIs("let*", 2, argCount);
                const malSequence* bindings =
                    VALUE_CAST(malSequence, list->item(1));
                int count = checkArgsEven("let*", bindings->count());
                malEnvPtr inner(new malEnv(env));
                for (int i = 0; i < count; i += 2) {
                    const malSymbol* var =
                        VALUE_CAST(malSymbol, bindings->item(i));
                    inner->set(var->value(), EVAL(bindings->item(i+1), inner));
                }
                ast = list->item(2);
                env = inner;
                continue; // TCO
            }

            if (special == "macroexpand") {
                checkArgsIs("macroexpand", 1, argCount);
                return macroExpand(list->item(1), env);
            }

            if (special == "quasiquote") {
                checkArgsIs("quasiquote", 1, argCount);
                ast = quasiquote(list->item(1));
                continue; // TCO
            }

            if (special == "quote") {
                checkArgsIs("quote", 1, argCount);
                return list->item(1);
            }

            if (special == "try*") {
                checkArgsIs("try*", 2, argCount);
                malValuePtr tryBody = list->item(1);
                const malList* catchBlock = VALUE_CAST(malList, list->item(2));

                checkArgsIs("catch*", 2, catchBlock->count() - 1);
                MAL_CHECK(VALUE_CAST(malSymbol,
                    catchBlock->item(0))->value() == "catch*",
                    "catch block must begin with catch*");

                // We don't need excSym at this scope, but we want to check
                // that the catch block is valid always, not just in case of
                // an exception.
                const malSymbol* excSym =
                    VALUE_CAST(malSymbol, catchBlock->item(1));

                malValuePtr excVal;

                try {
                    ast = EVAL(tryBody, env);
                }
                catch(String& s) {
                    excVal = mal::string(s);
                }
                catch (malEmptyInputException&) {
                    // Not an error, continue as if we got nil
                    ast = mal::nilValue();
                }
                catch(malValuePtr& o) {
                    excVal = o;
                };

                if (excVal) {
                    // we got some exception
                    env = malEnvPtr(new malEnv(env));
                    env->set(excSym->value(), excVal);
                    ast = catchBlock->item(2);
                }
                continue; // TCO
            }
        }

        // Now we're left with the case of a regular list to be evaluated.
        std::unique_ptr<malValueVec> items(list->evalItems(env));
        malValuePtr op = items->at(0);
        if (const malLambda* lambda = DYNAMIC_CAST(malLambda, op)) {
            ast = lambda->getBody();
            env = lambda->makeEnv(items->begin()+1, items->end());
            continue; // TCO
        }
        else {
            return APPLY(op, items->begin()+1, items->end());
        }
    }
}
Esempio n. 9
0
void __fastcall TFormMain::FormKeyDown(TObject *Sender, WORD &Key, TShiftState Shift)
{
  TRect R = RectNormalize(&Selection);
  unsigned tx = MAX(ListView->ItemIndex,0);

  //ShowMessage(Key);
  switch (Key)
  {
    case 221: {APPLY(cell->bot += 64) Key = 1; break;}
    case 219: {APPLY(cell->bot -= 64) Key = 1; break;}
    //case  36: {APPLY(cell->mid += 64) Key = 1; break;}
    //case  35: {APPLY(cell->mid -= 64) Key = 1; break;}
    case 'P': {APPLY(cell->top += 64) Key = 1; break;}
    case 'O': {APPLY(cell->top -= 64) Key = 1; break;}
    case 'L': {APPLY(cell->swi ^= CELL_SWI_LIGHT) Key = 1; break;}

    case  45: {if(tc)tx=(tx-1)%YETI_TEXTURE_MAX;APPLY(cell->btx=tx);Key=1;break;}
    case  46: {if(tc)tx=(tx+1)%YETI_TEXTURE_MAX;APPLY(cell->btx=tx);Key=1;break;}
    case  36: {if(tc)tx=(tx-1)%YETI_TEXTURE_MAX;APPLY(cell->wtx=tx);Key=1;break;}
    case  35: {if(tc)tx=(tx+1)%YETI_TEXTURE_MAX;APPLY(cell->wtx=tx);Key=1;break;}
    case  33: {if(tc)tx=(tx-1)%YETI_TEXTURE_MAX;APPLY(cell->ttx=tx);Key=1;break;}
    case  34: {if(tc)tx=(tx+1)%YETI_TEXTURE_MAX;APPLY(cell->ttx=tx);Key=1;break;}

    case 'F': {APPLY(cell_block(cell, true )); Key = 1; break;}
    case 'G': {APPLY(cell_block(cell, false)); Key = 1; break;}
    case 'E':
    {
      String Value = yeti->cells[R.top][R.left].ent;
      if (InputQuery("", "Enter Entity ID (0..255):", Value))
      {
        int ent = Value.ToIntDef(0);
        APPLY(cell->ent = ent);
        Key = 1;
      }
      break;
    }
    case  VK_LEFT     : {yeti->keyboard.left  = true; Key = 0; break;}
    case  VK_UP       : {yeti->keyboard.up    = true; Key = 0; break;}
    case  VK_RIGHT    : {yeti->keyboard.right = true; Key = 0; break;}
    case  VK_DOWN     : {yeti->keyboard.down  = true; Key = 0; break;}
    case  VK_CONTROL  : {yeti->keyboard.a     = true; Key = 0; break;}
    case  ' '         : {yeti->keyboard.b     = true; Key = 0; break;}
    case  'A'         : {yeti->keyboard.l     = true; Key = 0; break;}
    case  'Z'         : {yeti->keyboard.r     = true; Key = 0; break;}

    default:
    {
      //ShowMessage(Key);
    }
  }
  
  if (Key == 1)
  {
    Key = 0;
    yeti_default_lighting(yeti);
    PaintBoxPaint(PaintBox);
    FormPreview->TimerTimer(FormPreview->Timer);
    Modified = true;
    ListView->ItemIndex = tx;
    ListView->Selected->MakeVisible(False);
    tc = true;
  }
}
Esempio n. 10
0
static int print_attr(char *buffer, unsigned length,
		      const pj_stun_attr_hdr *ahdr)
{
    char *p = buffer, *end = buffer + length;
    const char *attr_name = pj_stun_get_attr_name(ahdr->type);
    char attr_buf[32];
    int len;

    if (*attr_name == '?') {
	pj_ansi_snprintf(attr_buf, sizeof(attr_buf), "Attr 0x%x", 
			 ahdr->type);
	attr_name = attr_buf;
    }

    len = pj_ansi_snprintf(p, end-p,
			   "  %s: length=%d",
			   attr_name,
			   (int)ahdr->length);
    APPLY();


    switch (ahdr->type) {
    case PJ_STUN_ATTR_MAPPED_ADDR:
    case PJ_STUN_ATTR_RESPONSE_ADDR:
    case PJ_STUN_ATTR_SOURCE_ADDR:
    case PJ_STUN_ATTR_CHANGED_ADDR:
    case PJ_STUN_ATTR_REFLECTED_FROM:
    case PJ_STUN_ATTR_XOR_PEER_ADDR:
    case PJ_STUN_ATTR_XOR_RELAYED_ADDR:
    case PJ_STUN_ATTR_XOR_MAPPED_ADDR:
    case PJ_STUN_ATTR_XOR_REFLECTED_FROM:
    case PJ_STUN_ATTR_ALTERNATE_SERVER:
	{
	    const pj_stun_sockaddr_attr *attr;

	    attr = (const pj_stun_sockaddr_attr*)ahdr;

	    if (attr->sockaddr.addr.sa_family == pj_AF_INET()) {
		len = pj_ansi_snprintf(p, end-p,
				       ", IPv4 addr=%s:%d\n",
				       pj_inet_ntoa(attr->sockaddr.ipv4.sin_addr),
				       pj_ntohs(attr->sockaddr.ipv4.sin_port));

	    } else if (attr->sockaddr.addr.sa_family == pj_AF_INET6()) {
		len = pj_ansi_snprintf(p, end-p,
				       ", IPv6 addr present\n");
	    } else {
		len = pj_ansi_snprintf(p, end-p,
				       ", INVALID ADDRESS FAMILY!\n");
	    }
	    APPLY();
	}
	break;

    case PJ_STUN_ATTR_CHANNEL_NUMBER:
	{
	    const pj_stun_uint_attr *attr;

	    attr = (const pj_stun_uint_attr*)ahdr;
	    len = pj_ansi_snprintf(p, end-p,
				   ", chnum=%u (0x%x)\n",
				   (int)PJ_STUN_GET_CH_NB(attr->value),
				   (int)PJ_STUN_GET_CH_NB(attr->value));
	    APPLY();
	}
	break;

    case PJ_STUN_ATTR_CHANGE_REQUEST:
    case PJ_STUN_ATTR_LIFETIME:
    case PJ_STUN_ATTR_BANDWIDTH:
    case PJ_STUN_ATTR_REQ_ADDR_TYPE:
    case PJ_STUN_ATTR_EVEN_PORT:
    case PJ_STUN_ATTR_REQ_TRANSPORT:
    case PJ_STUN_ATTR_TIMER_VAL:
    case PJ_STUN_ATTR_PRIORITY:
    case PJ_STUN_ATTR_FINGERPRINT:
    case PJ_STUN_ATTR_REFRESH_INTERVAL:
    case PJ_STUN_ATTR_ICMP:
	{
	    const pj_stun_uint_attr *attr;

	    attr = (const pj_stun_uint_attr*)ahdr;
	    len = pj_ansi_snprintf(p, end-p,
				   ", value=%u (0x%x)\n",
				   (pj_uint32_t)attr->value,
				   (pj_uint32_t)attr->value);
	    APPLY();
	}
	break;

    case PJ_STUN_ATTR_USERNAME:
    case PJ_STUN_ATTR_PASSWORD:
    case PJ_STUN_ATTR_REALM:
    case PJ_STUN_ATTR_NONCE:
    case PJ_STUN_ATTR_SOFTWARE:
	{
	    const pj_stun_string_attr *attr;

	    attr = (pj_stun_string_attr*)ahdr;
	    len = pj_ansi_snprintf(p, end-p,
				   ", value=\"%.*s\"\n",
				   (int)attr->value.slen,
				   attr->value.ptr);
	    APPLY();
	}
	break;

    case PJ_STUN_ATTR_ERROR_CODE:
	{
	    const pj_stun_errcode_attr *attr;

	    attr = (const pj_stun_errcode_attr*) ahdr;
	    len = pj_ansi_snprintf(p, end-p,
				   ", err_code=%d, reason=\"%.*s\"\n",
				   attr->err_code,
				   (int)attr->reason.slen,
				   attr->reason.ptr);
	    APPLY();
	}
	break;

    case PJ_STUN_ATTR_UNKNOWN_ATTRIBUTES:
	{
	    const pj_stun_unknown_attr *attr;
	    unsigned j;

	    attr = (const pj_stun_unknown_attr*) ahdr;

	    len = pj_ansi_snprintf(p, end-p,
				   ", unknown list:");
	    APPLY();

	    for (j=0; j<attr->attr_count; ++j) {
		len = pj_ansi_snprintf(p, end-p,
				       " %d",
				       (int)attr->attrs[j]);
		APPLY();
	    }
	}
	break;

    case PJ_STUN_ATTR_MESSAGE_INTEGRITY:
	{
	    const pj_stun_msgint_attr *attr;

	    attr = (const pj_stun_msgint_attr*) ahdr;
	    len = print_binary(p, (unsigned)(end-p), attr->hmac, 20);
	    APPLY();
	}
	break;

    case PJ_STUN_ATTR_DATA:
	{
	    const pj_stun_binary_attr *attr;

	    attr = (const pj_stun_binary_attr*) ahdr;
	    len = print_binary(p, (unsigned)(end-p), attr->data, attr->length);
	    APPLY();
	}
	break;
    case PJ_STUN_ATTR_ICE_CONTROLLED:
    case PJ_STUN_ATTR_ICE_CONTROLLING:
    case PJ_STUN_ATTR_RESERVATION_TOKEN:
	{
	    const pj_stun_uint64_attr *attr;
	    pj_uint8_t data[8];
	    int i;

	    attr = (const pj_stun_uint64_attr*) ahdr;

	    for (i=0; i<8; ++i)
		data[i] = ((const pj_uint8_t*)&attr->value)[7-i];

	    len = print_binary(p, (unsigned)(end-p), data, 8);
	    APPLY();
	}
	break;
    case PJ_STUN_ATTR_USE_CANDIDATE:
    case PJ_STUN_ATTR_DONT_FRAGMENT:
    default:
	len = pj_ansi_snprintf(p, end-p, "\n");
	APPLY();
	break;
    }

    return (int)(p-buffer);

on_return:
    return len;
}
  void
  ROWStageEquation<ELLIPTIC_EQ,GRAMIAN>::setup_rhs
  (unsigned int i,
   const double tolerance,
   const double t_n,
   const double h,
   const InfiniteVector<double,Index>& D_un,
   const std::list<InfiniteVector<double,Index> >& Dalpha_uj,
   const int jmax)
  {
    typedef InfiniteVector<double,Index> V;
    V help, w;
    
    const unsigned int stages = row_method_->A.row_dimension(); // for readability

    // start with zero rhs
    y.clear();

    // first summand DD^{-1}<A Psi,Psi>^T D^{-1}w, where
    // w = Du^{(n)} + DD_alpha^{-1}sum_{j=1}^{i-1} a_{i,j}D_alpha u_j
    if (i > 0) {
      typename std::list<V>::const_iterator it = Dalpha_uj.begin();
      for (unsigned int j = 0; j < i; j++, ++it) {
	w.add(row_method_->A(i,j), *it);
      }
      w.scale(this, -1);    // w *= D_alpha^{-1}
      w.scale(elliptic_, 1); // w *= D
    }
    w.add(D_un);
    APPLY(*elliptic_, w, tolerance, help, jmax, St04a); // yields -D^{-1}<A Psi,Psi>D^{-1}w
    help.scale(elliptic_, 1); // help *= D
    help.scale(-1.0); // result = -D(-D^{-1}<A Psi,Psi>^T D^{-1}w)
    y = help;
//     cout << "ROWStageEquation::setup_rhs() done, y1=" << endl << y << endl;
    
    // second summand <f(t_n+alpha_i*h),Psi>^T
    if (f_ != 0) {
      f_->set_time(t_n+h*row_method_->alpha_vector[i]);
      w.clear();
      expand(f_, elliptic_->basis(), true, jmax, w); // expand in the dual (!) basis
//       cout << "ROWStageEquation::setup_rhs() done, y2=" << endl << w << endl;
      y.add(w);
    }

    // third summand <Psi,Psi>^T D_alpha^{-1}sum_{j=1}^{i-1}(c_{i,j}/h)D_alpha u_j
    if (i > 0) {
      w.clear();
      typename std::list<V>::const_iterator it = Dalpha_uj.begin();
      for (unsigned int j = 0; j < i; j++, ++it) {
	w.add(row_method_->C(i,j)/h, *it);
      }
      w.scale(this, -1); // w *= D_alpha^{-1}
      APPLY(*gramian_, w, tolerance/(4*stages), help, jmax, St04a); // yields <Psi,Psi>^T D_alpha^{-1}sum(...)
//       cout << "ROWStageEquation::setup_rhs() done, y3=" << endl << help << endl;
      y.add(help);
    }
    
    // fourth summand h*gamma_i*<f'(t_n),Psi>^T
    if (ft_ != 0) {
      ft_->set_time(t_n);
      w.clear();
      expand(ft_, elliptic_->basis(), true, jmax, w); // expand in the dual (!) basis
//       cout << "ROWStageEquation::setup_rhs() done, y4=" << endl << w << endl;
      y.add(h*row_method_->gamma_vector[i], w);
    }
    
//     cout << "ROWStageEquation::setup_rhs() done, y=" << endl << y << endl;
  }
Esempio n. 12
0
void FormSetup::ApplyB()
{
	APPLY();
	Save.zapiszopcje();
}