void Astar::resetSort(int last)
{
// 根据步长进行堆排序
while(last > 1) {
int half = last/2;
auto itemHalf = (AstarItem*)_open->getObjectAtIndex(half);
auto itemLast = (AstarItem*)_open->getObjectAtIndex(last);
if(itemHalf->getF() <= itemLast->getF()) {
break;
}
/*if(((AstarItem*)_open->getObjectAtIndex(half))->getF() <= ((AstarItem*)_open->getObjectAtIndex(last))->getF()) {
break;
}*/
AstarItem* temp = (AstarItem*)_open->getObjectAtIndex(last);
_open->replaceObjectAtIndex(last, _open->getObjectAtIndex(half), false);
_open->replaceObjectAtIndex(half, temp, true);
//temp->release();
last = half;
}
}
Complexity Complexity::operator * (Complexity& t){
Complexity res(*this);
double f = getF()*t.getF() - getS()*t.getS();
double s = getF()*t.getS() + getF()*t.getS();
res.set(f, s);
return res;
}
// Print the BWT
void SBWT::print(const ReadTable* pRT, const SuffixArray* pSA) const
{
std::cout << "i\tL(i)\tF(i)\tO(-,i)\tSUFF\n";
for(size_t i = 0; i < m_bwStr.length(); ++i)
{
assert(getF(i) == pSA->getSuffix(i, pRT)[0]);
std::cout << i << "\t" << m_bwStr.get(i) << "\t" << getF(i) << "\t" << m_occurrence.get(m_bwStr, i) << pSA->getSuffix(i, pRT) << "\n";
}
}
NOX::Abstract::Group::ReturnType
NOX::Belos::Group::computeNewton(NOX::Parameter::List& params)
{
if (isValidNewton)
return NOX::Abstract::Group::Ok;
if (!isF()) {
std::cerr << "ERROR: NOX::Belos::Group::computeNewton() - invalid RHS" << std::endl;
throw "NOX Error";
}
if (!isJacobian()) {
std::cerr << "ERROR: NOX::Belos::Group::computeNewton() - invalid Jacobian"
<< std::endl;
throw "NOX Error";
}
Abstract::Group::ReturnType status;
// zero out newton vec -- used as initial guess for some linear solvers
newtonVecPtr->init(0.0);
status = applyJacobianInverse(params, getF(), *newtonVecPtr);
newtonVecPtr->scale(-1.0);
// Update state EVEN IF LINEAR SOLVE FAILED
// We still may want to use the vector even it it just missed it's
isValidNewton = true;
return status;
}
int getF(string &s, string &p, int i, int j) {
if (F)
return F;
// case 1: regex is empty
if (j < 0) {
// s must be empty
return F = (i < 0 ? 1 : 2);
}
// case 2: start with a dot
if (p[j] == '.') {
// s is not empty, check next
if (i >= 0)
return F = getF(s, p, i - 1, j - 1);
else
return F = 2;
}
// case 3: start with a char
if (p[j] != '*') {
// s shares the same first letter with p, check next
if (i >= 0 && s[i] == p[j])
return F = getF(s, p, i - 1, j - 1);
else
return F = 2;
}
// case 4: start with a asterisk
char prev = j ? p[j - 1] : '-';
if (prev == '*') return F = getF(s, p, i, j - 1);
if (getF(s, p, i, j - 2) == 1) // skip
return F = 1;
for (int k = 0; i - k >= 0; ++k)
if (prev == '.' || prev == s[i - k]) {
// it matches
if (getF(s, p, i - k - 1, j - 2) == 1) {
return F = 1;
}
} else {
break;
}
return F = 2;
}
double
NOX::Belos::Group::getNormNewtonSolveResidual() const
{
NOX::Abstract::Group::ReturnType status;
Teuchos::RCP<NOX::Abstract::Vector> residual =
getF().clone(NOX::DeepCopy);
status = applyJacobian(*newtonVecPtr, *residual);
if (status != NOX::Abstract::Group::Ok) {
std::cerr << "Error: NOX::Belos::Group::getNormNewtonSolveResidual() -- applyJacobian failed!" << std::endl;
throw "NOX Error";
}
residual->update(1.0, getF(), 1.0);
double resid_norm = residual->norm();
return resid_norm;
}
void UVarHist::logDataDouble(int idx)
{
if (isLogOpen())
{
double * data = &histData[idx * colCnt];
UTime * t = & histTime[idx];
// save timestamp
fprintf(getF(), "%lu.%06lu", t->getSec(), t->getMicrosec());
// save data elements
for (int i = 0; i < colCnt; i++)
fprintf(getF(), " %.10g", data[i]);
// end line
fprintf(getF(), "\n");
// remenber to flush if requested
if (logFlush)
fflush(getF());
}
}
void Union(int id1, int id2)
{
int fA, fB;
fA = getF(id1);
fB = getF(id2);
if (fA == fB)
return;
if (set[fA] < set[fB])
{
set[fA] += set[fB];
set[fB] = fA;
}
else
{
set[fB] += set[fA];
set[fA] = fB;
}
}
void uion(int id1, int id2)
{
int fA, fB;
fA = getF(id1);
fB = getF(id2);
if (fA == fB)
return;
if (students[fA] < students[fB])
{
students[fA] += students[fB];
students[fB] = fA;
}
else
{
students[fB] += students[fA];
students[fA] = fB;
}
}
int longestIncreasingContinuousSubsequenceII(vector<vector<int>>& A) {
// Write your code here
if(A.size() == 0 || A[0].size() == 0) return 0;
int m = A.size(), n = A[0].size();
vector<vector<int>> f(m, vector<int>(n, 0));
int ans = 0;
for(int i = 0; i < m; i++)
for(int j = 0; j < n; j++)
ans = max(ans, getF(A, f, i, j));
return ans;
}
/**
* @param A an integer matrix
* @return an integer
*/
int getF(vector<vector<int>>& A, vector<vector<int>>& f, int x, int y) {
if(f[x][y] > 0) return f[x][y];
int a = 1;
int g[4][2] = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};
for(int i = 0;i < 4; i++) {
int j = x + g[i][0], k = y + g[i][1];
if(j >= 0 && j < A.size() && k >= 0 && k < A[0].size() && A[j][k] > A[x][y])
a = max(a, 1+getF(A, f, j, k));
}
f[x][y] = a;
return a;
}
Eigen::MatrixXd TranslationRotation3D::adjoint() const {
double F_ptr[4 * 4];
Eigen::Map<const Eigen::Matrix<double, 4, 4, Eigen::RowMajor> > F(F_ptr);
getF(F_ptr);
Eigen::MatrixXd adj(6, 6);
Eigen::Vector3d T = F.topRightCorner<3, 1>();
Eigen::Matrix3d R = F.topLeftCorner<3, 3>();
Eigen::Matrix3d skewT;
skewT << 0.0, -T(2), T(1), T(2), 0.0, -T(0), -T(1), T(0), 0.0;
adj << R, skewT *R, Eigen::Matrix3d::Zero(), R;
return adj;
}
peano::applications::faxen::records::RegularGridCell peano::applications::faxen::records::RegularGridCellPacked::convert() const{
return RegularGridCell(
getP(),
getU(),
getV(),
getF(),
getG(),
getRhs(),
getRes(),
getIsInside()
);
}
const Vector&
PFEMElement2DBubble::getResistingForceIncInertia()
{
// resize P
int ndf = this->getNumDOF();
P.resize(ndf);
P.Zero();
// get velocity, accleration
Vector v(ndf), vdot(ndf);
for(int i=0; i<3; i++) {
const Vector& accel = nodes[2*i]->getTrialAccel();
vdot(numDOFs(2*i)) = accel(0);
vdot(numDOFs(2*i)+1) = accel(1);
const Vector& accel2 = nodes[2*i+1]->getTrialAccel(); // pressure
vdot(numDOFs(2*i+1)) = accel2(0);
const Vector& vel = nodes[2*i]->getTrialVel();
v(numDOFs(2*i)) = vel(0);
v(numDOFs(2*i)+1) = vel(1);
const Vector& vel2 = nodes[2*i+1]->getTrialVel(); // pressure
v(numDOFs(2*i+1)) = vel2(0);
}
// bubble force
Vector fp(3);
getFp(fp);
// internal force
P.addMatrixVector(1.0, getMass(), vdot, 1.0);
P.addMatrixVector(1.0, getDamp(), v, 1.0);
// external force
Vector F(6);
getF(F);
for(int i=0; i<3; i++) {
P(numDOFs(2*i)) -= F(2*i);
P(numDOFs(2*i)+1) -= F(2*i+1);
P(numDOFs(2*i+1)) -= fp(i);
}
//opserr<<"F = "<<F;
return P;
}
int LuaArgs::getF(int idx, const char *key)
{
if (tbl > 0 && lua_checkstack(L, 1)) {
lua_getfield(L, tbl, key);
if (!lua_isfunction(L, -1) && idx > 0) {
lua_pop(L, 1);
lua_pushinteger(L, idx);
lua_gettable(L, tbl);
}
int ret = fcopy(-1);
lua_pop(L, 1);
return ret;
} else {
return getF(idx);
}
}
//----------------------------------------------------------------------------------
void FunctionsSingleton::coutAll() const
{
std::cout << getD() << std::endl;
std::cout << getF() << std::endl;
std::cout << getG() << std::endl;
std::cout << getM() << std::endl;
std::cout << getN() << std::endl;
std::cout << getP() << std::endl;
std::cout << getQ() << std::endl;
std::cout << getR() << std::endl;
std::cout << getW() << std::endl;
std::cout << "Alpha: " << mAlpha << std::endl;
std::cout << "Beta: " << mBeta << std::endl;
std::cout << "Gamma: " << mGamma << std::endl;
}
void ExtendedKalman::predict() {
{
Matrix F;
getF(F, X);
// X = F * X
X.dotSelf(F, true);
// P = F * P * F.T + Q
P.dotSelf(F, true).dotSelf(F.transposed());
}
{
Matrix Q;
getQ(Q);
P += Q;
}
}
// Print the current time and A/B signal levels on the console
void showTime() {
unsigned int s = getSeconds();
//-- Newline + whole time every minute
if ( s == 0 )
p("\r\n%02u%s:%02u:%02u ", getHours(), getDST() ? "D" : "", getMinutes(), s);
else if ( (s % 10 ) == 0)
p("%02u", s );
else
p("-");
//-- Show the A/B/D/E pulse status, F level
if (getA()) p("A");
if (getB()) p("B");
if (getD()) p("D");
if (getE()) p("E");
if (getF()) p("F");
}
void peano::applications::faxen::records::RegularGridCellPacked::toString (std::ostream& out) const {
out << "(";
out << "P:" << getP();
out << ",";
out << "U:" << getU();
out << ",";
out << "V:" << getV();
out << ",";
out << "F:" << getF();
out << ",";
out << "G:" << getG();
out << ",";
out << "rhs:" << getRhs();
out << ",";
out << "res:" << getRes();
out << ",";
out << "isInside:" << getIsInside();
out << ")";
}
int main(int argc, char **argv)
{
walberla::Environment env( argc, argv );
const uint_t cells [] = { 1,1,1 };
const uint_t blockCount [] = { 1, 1,1 };
const uint_t nrOfTimeSteps = 20;
// Create BlockForest
auto blocks = blockforest::createUniformBlockGrid(blockCount[0],blockCount[1],blockCount[2], //blocks
cells[0],cells[1],cells[2], //cells
1, //dx
false, //one block per process
true,true,true); //periodicity
// In addition to the normal GhostLayerField's we allocated additionally a field containing the whole global simulation domain for each block
// we can then check if the GhostLayer communication is correct, by comparing the small field to the corresponding part of the big field
BlockDataID pdfField = field::addToStorage<PdfField>( blocks, "Src" );
// Init src field with some values
for( auto blockIt = blocks->begin(); blockIt != blocks->end(); ++blockIt ) // block loop
{
// Init PDF field
PdfField * src = blockIt->getData<PdfField>(pdfField);
for( auto cellIt = src->beginWithGhostLayerXYZ(); cellIt != src->end(); ++cellIt ) // over all x,y,z,f
{
for( auto d = stencil::D3Q19::begin(); d != stencil::D3Q19::end(); ++d )
cellIt.getF( d.toIdx() ) = real_c( d.toIdx() );
}
}
// Create TimeLoop
SweepTimeloop timeloop (blocks, nrOfTimeSteps );
GUI gui (timeloop, blocks, argc, argv);
gui.run();
//timeloop.singleStep();
return EXIT_SUCCESS;
}
void DepositionCell::preUpdate(double epsilon[], BaseCell* neighbors[], Grid *grid, Vector3i ) {
double surroundingConcentration = 0;
for (int i = 0; i < 9; i++) {
BaseCell* neighbor = neighbors[i];
if (neighbor != 0) {
double newF = (1 - 1 / epsilon[1]) * getF(i, 1) + LBUtil::W[9][i] * concentration / epsilon[1];
neighbor->setNextF(i, newF, 1);
if (i != 0) {
double neighborConcentration = 0;
if (neighbor->isFluid()) {
neighborConcentration = neighbor->getP(0);
} else if (dynamic_cast<DepositionWall*>(neighbor) != 0) {
neighborConcentration = 1;
}
surroundingConcentration += neighborConcentration * 9 / 5 * LBUtil::W[9][i];
}
}
}
deposited += surroundingConcentration * concentration * grid->getConfig()->getDepositionRate();
if (deposited > 1) {
deposited = 1;
}
}
int main()
{
char c;
int ncase, i, a, b, m, n;
int oppos[N];
scanf("%d", &ncase);
while(ncase--)
{
makeSet();
memset(oppos, -1, sizeof(oppos));
scanf("%d %d", &n, &m);
for(i = 0;i < m;i++)
{
getchar();
scanf("%c %d %d", &c, &a, &b);
if(c == 'A')
{
if (oppos[a] == -1 || oppos[b] == -1)
printf("Not sure yet.\n");
else if (getF(a) == getF(b))
printf("In the same gang.\n");
else if (getF(a) == getF(oppos[b]) || getF(b) == getF(oppos[a]))
printf("In different gangs.\n");
else
printf("Not sure yet.\n");
}
else
{
if (oppos[a] == -1)
oppos[a] = b;
if (oppos[b] == -1)
oppos[b] = a;
Union(a, oppos[b]);
Union(b, oppos[a]);
}
}
}
return 0;
}
inline int getFlagC(){
return (getF()&0x10)>>4;
}
inline int getFlagH(){
return (getF()&0x20)>>5;
}
inline int getFlagN(){
return (getF()&0x40)>>6;
}
inline int getFlagZ(){
return (getF()&0x80)>>7;
}
inline void clearFlagC(){
writeF(getF()&(~(0x10)));
}
inline void clearFlagH(){
writeF(getF()&(~(0x20)));
}
inline void clearFlagN(){
writeF(getF()&(~(0x40)));
}
inline void clearFlagZ(){
writeF(getF()&(~(0x80)));
}
