void RegisterKeyboardControls(KeyboardControls* controls){ keyboardControls.push_back(controls); }
int PointFloatShapeFeatureExtractor::extractFeatures(const LTKTraceGroup& inTraceGroup, vector<LTKShapeFeaturePtr>& outFeatureVec) { LOG( LTKLogger::LTK_LOGLEVEL_DEBUG) << "Entering " << "PointFloatShapeFeatureExtractor::extractFeatures()" << endl; PointFloatShapeFeature *featurePtr = NULL; float x,y,deltax; int numPoints=0; // number of pts int count=0; int currentStrokeSize; float sintheta, costheta,sqsum; int i; int numberOfTraces = inTraceGroup.getNumTraces(); if (numberOfTraces == 0 ) { LOG( LTKLogger::LTK_LOGLEVEL_ERR) << "Error: " << EEMPTY_TRACE_GROUP << " : " << getErrorMessage(EEMPTY_TRACE_GROUP)<< " PointFloatShapeFeatureExtractor::extractFeatures" <<endl; LTKReturnError(EEMPTY_TRACE_GROUP); } LTKTraceVector allTraces = inTraceGroup.getAllTraces(); LTKTraceVector::iterator traceIter = allTraces.begin(); LTKTraceVector::iterator traceEnd = allTraces.end(); //***CONCATENTATING THE STROKES*** for (; traceIter != traceEnd ; ++traceIter) { floatVector tempxVec, tempyVec; (*traceIter).getChannelValues("X", tempxVec); (*traceIter).getChannelValues("Y", tempyVec); // Number of points in the stroke numPoints = numPoints + tempxVec.size(); } //***THE CONCATENATED FULL STROKE*** floatVector xVec(numPoints); floatVector yVec(numPoints); traceIter = allTraces.begin(); traceEnd = allTraces.end(); boolVector penUp; // Add the penUp here for (; traceIter != traceEnd ; ++traceIter) { floatVector tempxVec, tempyVec; (*traceIter).getChannelValues("X", tempxVec); (*traceIter).getChannelValues("Y", tempyVec); currentStrokeSize = tempxVec.size(); if (currentStrokeSize == 0) { LOG( LTKLogger::LTK_LOGLEVEL_ERR) << "Error: " << EEMPTY_TRACE << " : " << getErrorMessage(EEMPTY_TRACE) << " PointFloatShapeFeatureExtractor::extractFeatures" <<endl; LTKReturnError(EEMPTY_TRACE); } for( int point=0; point < currentStrokeSize ; point++ ) { xVec[count] = tempxVec[point]; yVec[count] = tempyVec[point]; count++; if(point == currentStrokeSize - 1 ) { penUp.push_back(true); } else { penUp.push_back(false); } } } //***CONCATENTATING THE STROKES*** vector<float> theta(numPoints); vector<float> delta_x(numPoints-1); vector<float> delta_y(numPoints-1); for(i=0; i<numPoints-1; ++i) { delta_x[i]=xVec[i+1]-xVec[i]; delta_y[i]=yVec[i+1]-yVec[i]; } //Add the controlInfo here sqsum = sqrt( pow(xVec[0],2)+ pow(yVec[0],2))+ EPS; sintheta = (1+yVec[0]/sqsum)*PREPROC_DEF_NORMALIZEDSIZE/2; costheta = (1+xVec[0]/sqsum)*PREPROC_DEF_NORMALIZEDSIZE/2; featurePtr = new PointFloatShapeFeature(xVec[0], yVec[0], sintheta, costheta, penUp[0]); outFeatureVec.push_back(LTKShapeFeaturePtr(featurePtr)); featurePtr = NULL; for( i=1; i<numPoints; ++i) { //Add the controlInfo here sqsum = sqrt(pow(delta_x[i-1],2) + pow(delta_y[i-1],2))+EPS; sintheta = (1+delta_y[i-1]/sqsum)*PREPROC_DEF_NORMALIZEDSIZE/2; costheta = (1+delta_x[i-1]/sqsum)*PREPROC_DEF_NORMALIZEDSIZE/2; featurePtr = new PointFloatShapeFeature(xVec[i], yVec[i], sintheta, costheta, penUp[i]); //***POPULATING THE FEATURE VECTOR*** outFeatureVec.push_back(LTKShapeFeaturePtr(featurePtr)); featurePtr = NULL; } LOG( LTKLogger::LTK_LOGLEVEL_DEBUG) << "Exiting " << "PointFloatShapeFeatureExtractor::extractFeatures()" << endl; return SUCCESS; }
void MaxHeapInsert(vector<int>& A, int key) { A.push_back(INT_MIN); HeapIncreaseKey(A, A.size() - 1, key); }
void ParseCommandLine(int argc, char **argv) { static const char *help = "Bitcoin-seeder\n" "Usage: %s -h <host> -n <ns> [-m <mbox>] [-t <threads>] [-p <port>]\n" "\n" "Options:\n" "-s <seed> Seed node to collect peers from (replaces default)\n" "-h <host> Hostname of the DNS seed\n" "-n <ns> Hostname of the nameserver\n" "-m <mbox> E-Mail address reported in SOA records\n" "-t <threads> Number of crawlers to run in parallel (default 24)\n" "-d <threads> Number of DNS server threads (default 24)\n" "-p <port> UDP port to listen on (default 53)\n" "-o <ip:port> Tor proxy IP/Port\n" "--p2port <port> P2P port to connect to\n" "--magic <hex> Magic string/network prefix\n" "--wipeban Wipe list of banned nodes\n" "--wipeignore Wipe list of ignored nodes\n" "-?, --help Show this text\n" "\n"; bool showHelp = false; while(1) { static struct option long_options[] = { {"seed", required_argument, 0, 's'}, {"host", required_argument, 0, 'h'}, {"ns", required_argument, 0, 'n'}, {"mbox", required_argument, 0, 'm'}, {"threads", required_argument, 0, 't'}, {"dnsthreads", required_argument, 0, 'd'}, {"port", required_argument, 0, 'p'}, {"onion", required_argument, 0, 'o'}, {"p2port", required_argument, 0, 'b'}, {"magic", required_argument, 0, 'k'}, {"wipeban", no_argument, &fWipeBan, 1}, {"wipeignore", no_argument, &fWipeBan, 1}, {"help", no_argument, 0, 'h'}, {0, 0, 0, 0} }; int option_index = 0; int c = getopt_long(argc, argv, "s:h:n:m:t:p:d:o:b:k:", long_options, &option_index); if (c == -1) break; switch (c) { case 's': { vSeeds.push_back(optarg); break; } case 'h': { host = optarg; break; } case 'm': { mbox = optarg; break; } case 'n': { ns = optarg; break; } case 't': { int n = strtol(optarg, NULL, 10); if (n > 0 && n < 1000) nThreads = n; break; } case 'd': { int n = strtol(optarg, NULL, 10); if (n > 0 && n < 1000) nDnsThreads = n; break; } case 'p': { int p = strtol(optarg, NULL, 10); if (p > 0 && p < 65536) nPort = p; break; } case 'o': { tor = optarg; break; } case 'b': { int p = strtol(optarg, NULL, 10); if (p > 0 && p < 65536) nP2Port = p; break; } case 'k': { long int n; unsigned int c; magic = optarg; if (strlen(magic)!=8) break; n = strtol(magic, NULL, 16); if (n==0 && strcmp(magic, "00000000")) break; for (n=0; n<4; ++n) { sscanf(&magic[n*2], "%2x", &c); pchMessageStart[n] = (unsigned char) (c & 0xff); } break; } case '?': { showHelp = true; break; } } } if (host != NULL && ns == NULL) showHelp = true; if (showHelp) fprintf(stderr, help, argv[0]); }
void Assign_element::add_cond(string &c) { cond.push_back(c); }
bool EvalScript(vector<vector<unsigned char> >& stack, const CScript& script, const CTransaction& txTo, unsigned int nIn, unsigned int flags, int nHashType) { CScript::const_iterator pc = script.begin(); CScript::const_iterator pend = script.end(); CScript::const_iterator pbegincodehash = script.begin(); opcodetype opcode; valtype vchPushValue; vector<bool> vfExec; vector<valtype> altstack; if (script.size() > 10000) return false; int nOpCount = 0; try { while (pc < pend) { bool fExec = !count(vfExec.begin(), vfExec.end(), false); // // Read instruction // if (!script.GetOp(pc, opcode, vchPushValue)) return false; if (vchPushValue.size() > MAX_SCRIPT_ELEMENT_SIZE) return false; // Note how OP_RESERVED does not count towards the opcode limit. if (opcode > OP_16 && ++nOpCount > 201) return false; if (opcode == OP_CAT || opcode == OP_SUBSTR || opcode == OP_LEFT || opcode == OP_RIGHT || opcode == OP_INVERT || opcode == OP_AND || opcode == OP_OR || opcode == OP_XOR || opcode == OP_2MUL || opcode == OP_2DIV || opcode == OP_MUL || opcode == OP_DIV || opcode == OP_MOD || opcode == OP_LSHIFT || opcode == OP_RSHIFT) return false; // Disabled opcodes. if (fExec && 0 <= opcode && opcode <= OP_PUSHDATA4) stack.push_back(vchPushValue); else if (fExec || (OP_IF <= opcode && opcode <= OP_ENDIF)) switch (opcode) { // // Push value // case OP_1NEGATE: case OP_1: case OP_2: case OP_3: case OP_4: case OP_5: case OP_6: case OP_7: case OP_8: case OP_9: case OP_10: case OP_11: case OP_12: case OP_13: case OP_14: case OP_15: case OP_16: { // ( -- value) CScriptNum bn((int)opcode - (int)(OP_1 - 1)); stack.push_back(bn.getvch()); } break; // // Control // case OP_NOP: case OP_NOP1: case OP_NOP2: case OP_NOP3: case OP_NOP4: case OP_NOP5: case OP_NOP6: case OP_NOP7: case OP_NOP8: case OP_NOP9: case OP_NOP10: break; case OP_IF: case OP_NOTIF: { // <expression> if [statements] [else [statements]] endif bool fValue = false; if (fExec) { if (stack.size() < 1) return false; valtype& vch = stacktop(-1); fValue = CastToBool(vch); if (opcode == OP_NOTIF) fValue = !fValue; popstack(stack); } vfExec.push_back(fValue); } break; case OP_ELSE: { if (vfExec.empty()) return false; vfExec.back() = !vfExec.back(); } break; case OP_ENDIF: { if (vfExec.empty()) return false; vfExec.pop_back(); } break; case OP_VERIFY: { // (true -- ) or // (false -- false) and return if (stack.size() < 1) return false; bool fValue = CastToBool(stacktop(-1)); if (fValue) popstack(stack); else return false; } break; case OP_RETURN: { return false; } break; // // Stack ops // case OP_TOALTSTACK: { if (stack.size() < 1) return false; altstack.push_back(stacktop(-1)); popstack(stack); } break; case OP_FROMALTSTACK: { if (altstack.size() < 1) return false; stack.push_back(altstacktop(-1)); popstack(altstack); } break; case OP_2DROP: { // (x1 x2 -- ) if (stack.size() < 2) return false; popstack(stack); popstack(stack); } break; case OP_2DUP: { // (x1 x2 -- x1 x2 x1 x2) if (stack.size() < 2) return false; valtype vch1 = stacktop(-2); valtype vch2 = stacktop(-1); stack.push_back(vch1); stack.push_back(vch2); } break; case OP_3DUP: { // (x1 x2 x3 -- x1 x2 x3 x1 x2 x3) if (stack.size() < 3) return false; valtype vch1 = stacktop(-3); valtype vch2 = stacktop(-2); valtype vch3 = stacktop(-1); stack.push_back(vch1); stack.push_back(vch2); stack.push_back(vch3); } break; case OP_2OVER: { // (x1 x2 x3 x4 -- x1 x2 x3 x4 x1 x2) if (stack.size() < 4) return false; valtype vch1 = stacktop(-4); valtype vch2 = stacktop(-3); stack.push_back(vch1); stack.push_back(vch2); } break; case OP_2ROT: { // (x1 x2 x3 x4 x5 x6 -- x3 x4 x5 x6 x1 x2) if (stack.size() < 6) return false; valtype vch1 = stacktop(-6); valtype vch2 = stacktop(-5); stack.erase(stack.end()-6, stack.end()-4); stack.push_back(vch1); stack.push_back(vch2); } break; case OP_2SWAP: { // (x1 x2 x3 x4 -- x3 x4 x1 x2) if (stack.size() < 4) return false; swap(stacktop(-4), stacktop(-2)); swap(stacktop(-3), stacktop(-1)); } break; case OP_IFDUP: { // (x - 0 | x x) if (stack.size() < 1) return false; valtype vch = stacktop(-1); if (CastToBool(vch)) stack.push_back(vch); } break; case OP_DEPTH: { // -- stacksize CScriptNum bn(stack.size()); stack.push_back(bn.getvch()); } break; case OP_DROP: { // (x -- ) if (stack.size() < 1) return false; popstack(stack); } break; case OP_DUP: { // (x -- x x) if (stack.size() < 1) return false; valtype vch = stacktop(-1); stack.push_back(vch); } break; case OP_NIP: { // (x1 x2 -- x2) if (stack.size() < 2) return false; stack.erase(stack.end() - 2); } break; case OP_OVER: { // (x1 x2 -- x1 x2 x1) if (stack.size() < 2) return false; valtype vch = stacktop(-2); stack.push_back(vch); } break; case OP_PICK: case OP_ROLL: { // (xn ... x2 x1 x0 n - xn ... x2 x1 x0 xn) // (xn ... x2 x1 x0 n - ... x2 x1 x0 xn) if (stack.size() < 2) return false; int n = CScriptNum(stacktop(-1)).getint(); popstack(stack); if (n < 0 || n >= (int)stack.size()) return false; valtype vch = stacktop(-n-1); if (opcode == OP_ROLL) stack.erase(stack.end()-n-1); stack.push_back(vch); } break; case OP_ROT: { // (x1 x2 x3 -- x2 x3 x1) // x2 x1 x3 after first swap // x2 x3 x1 after second swap if (stack.size() < 3) return false; swap(stacktop(-3), stacktop(-2)); swap(stacktop(-2), stacktop(-1)); } break; case OP_SWAP: { // (x1 x2 -- x2 x1) if (stack.size() < 2) return false; swap(stacktop(-2), stacktop(-1)); } break; case OP_TUCK: { // (x1 x2 -- x2 x1 x2) if (stack.size() < 2) return false; valtype vch = stacktop(-1); stack.insert(stack.end()-2, vch); } break; case OP_SIZE: { // (in -- in size) if (stack.size() < 1) return false; CScriptNum bn(stacktop(-1).size()); stack.push_back(bn.getvch()); } break; // // Bitwise logic // case OP_EQUAL: case OP_EQUALVERIFY: //case OP_NOTEQUAL: // use OP_NUMNOTEQUAL { // (x1 x2 - bool) if (stack.size() < 2) return false; valtype& vch1 = stacktop(-2); valtype& vch2 = stacktop(-1); bool fEqual = (vch1 == vch2); // OP_NOTEQUAL is disabled because it would be too easy to say // something like n != 1 and have some wiseguy pass in 1 with extra // zero bytes after it (numerically, 0x01 == 0x0001 == 0x000001) //if (opcode == OP_NOTEQUAL) // fEqual = !fEqual; popstack(stack); popstack(stack); stack.push_back(fEqual ? vchTrue : vchFalse); if (opcode == OP_EQUALVERIFY) { if (fEqual) popstack(stack); else return false; } } break; // // Numeric // case OP_1ADD: case OP_1SUB: case OP_NEGATE: case OP_ABS: case OP_NOT: case OP_0NOTEQUAL: { // (in -- out) if (stack.size() < 1) return false; CScriptNum bn(stacktop(-1)); switch (opcode) { case OP_1ADD: bn += bnOne; break; case OP_1SUB: bn -= bnOne; break; case OP_NEGATE: bn = -bn; break; case OP_ABS: if (bn < bnZero) bn = -bn; break; case OP_NOT: bn = (bn == bnZero); break; case OP_0NOTEQUAL: bn = (bn != bnZero); break; default: assert(!"invalid opcode"); break; } popstack(stack); stack.push_back(bn.getvch()); } break; case OP_ADD: case OP_SUB: case OP_BOOLAND: case OP_BOOLOR: case OP_NUMEQUAL: case OP_NUMEQUALVERIFY: case OP_NUMNOTEQUAL: case OP_LESSTHAN: case OP_GREATERTHAN: case OP_LESSTHANOREQUAL: case OP_GREATERTHANOREQUAL: case OP_MIN: case OP_MAX: { // (x1 x2 -- out) if (stack.size() < 2) return false; CScriptNum bn1(stacktop(-2)); CScriptNum bn2(stacktop(-1)); CScriptNum bn(0); switch (opcode) { case OP_ADD: bn = bn1 + bn2; break; case OP_SUB: bn = bn1 - bn2; break; case OP_BOOLAND: bn = (bn1 != bnZero && bn2 != bnZero); break; case OP_BOOLOR: bn = (bn1 != bnZero || bn2 != bnZero); break; case OP_NUMEQUAL: bn = (bn1 == bn2); break; case OP_NUMEQUALVERIFY: bn = (bn1 == bn2); break; case OP_NUMNOTEQUAL: bn = (bn1 != bn2); break; case OP_LESSTHAN: bn = (bn1 < bn2); break; case OP_GREATERTHAN: bn = (bn1 > bn2); break; case OP_LESSTHANOREQUAL: bn = (bn1 <= bn2); break; case OP_GREATERTHANOREQUAL: bn = (bn1 >= bn2); break; case OP_MIN: bn = (bn1 < bn2 ? bn1 : bn2); break; case OP_MAX: bn = (bn1 > bn2 ? bn1 : bn2); break; default: assert(!"invalid opcode"); break; } popstack(stack); popstack(stack); stack.push_back(bn.getvch()); if (opcode == OP_NUMEQUALVERIFY) { if (CastToBool(stacktop(-1))) popstack(stack); else return false; } } break; case OP_WITHIN: { // (x min max -- out) if (stack.size() < 3) return false; CScriptNum bn1(stacktop(-3)); CScriptNum bn2(stacktop(-2)); CScriptNum bn3(stacktop(-1)); bool fValue = (bn2 <= bn1 && bn1 < bn3); popstack(stack); popstack(stack); popstack(stack); stack.push_back(fValue ? vchTrue : vchFalse); } break; // // Crypto // case OP_RIPEMD160: case OP_SHA1: case OP_SHA256: case OP_HASH160: case OP_HASH256: { // (in -- hash) if (stack.size() < 1) return false; valtype& vch = stacktop(-1); valtype vchHash((opcode == OP_RIPEMD160 || opcode == OP_SHA1 || opcode == OP_HASH160) ? 20 : 32); if (opcode == OP_RIPEMD160) CRIPEMD160().Write(&vch[0], vch.size()).Finalize(&vchHash[0]); else if (opcode == OP_SHA1) CSHA1().Write(&vch[0], vch.size()).Finalize(&vchHash[0]); else if (opcode == OP_SHA256) CSHA256().Write(&vch[0], vch.size()).Finalize(&vchHash[0]); else if (opcode == OP_HASH160) CHash160().Write(&vch[0], vch.size()).Finalize(&vchHash[0]); else if (opcode == OP_HASH256) CHash256().Write(&vch[0], vch.size()).Finalize(&vchHash[0]); popstack(stack); stack.push_back(vchHash); } break; case OP_CODESEPARATOR: { // Hash starts after the code separator pbegincodehash = pc; } break; case OP_CHECKSIG: case OP_CHECKSIGVERIFY: { // (sig pubkey -- bool) if (stack.size() < 2) return false; valtype& vchSig = stacktop(-2); valtype& vchPubKey = stacktop(-1); // Subset of script starting at the most recent codeseparator CScript scriptCode(pbegincodehash, pend); // Drop the signature, since there's no way for a signature to sign itself scriptCode.FindAndDelete(CScript(vchSig)); bool fSuccess = IsCanonicalSignature(vchSig, flags) && IsCanonicalPubKey(vchPubKey, flags) && CheckSig(vchSig, vchPubKey, scriptCode, txTo, nIn, nHashType, flags); popstack(stack); popstack(stack); stack.push_back(fSuccess ? vchTrue : vchFalse); if (opcode == OP_CHECKSIGVERIFY) { if (fSuccess) popstack(stack); else return false; } } break; case OP_CHECKMULTISIG: case OP_CHECKMULTISIGVERIFY: { // ([sig ...] num_of_signatures [pubkey ...] num_of_pubkeys -- bool) int i = 1; if ((int)stack.size() < i) return false; int nKeysCount = CScriptNum(stacktop(-i)).getint(); if (nKeysCount < 0 || nKeysCount > 20) return false; nOpCount += nKeysCount; if (nOpCount > 201) return false; int ikey = ++i; i += nKeysCount; if ((int)stack.size() < i) return false; int nSigsCount = CScriptNum(stacktop(-i)).getint(); if (nSigsCount < 0 || nSigsCount > nKeysCount) return false; int isig = ++i; i += nSigsCount; if ((int)stack.size() < i) return false; // Subset of script starting at the most recent codeseparator CScript scriptCode(pbegincodehash, pend); // Drop the signatures, since there's no way for a signature to sign itself for (int k = 0; k < nSigsCount; k++) { valtype& vchSig = stacktop(-isig-k); scriptCode.FindAndDelete(CScript(vchSig)); } bool fSuccess = true; while (fSuccess && nSigsCount > 0) { valtype& vchSig = stacktop(-isig); valtype& vchPubKey = stacktop(-ikey); // Check signature bool fOk = IsCanonicalSignature(vchSig, flags) && IsCanonicalPubKey(vchPubKey, flags) && CheckSig(vchSig, vchPubKey, scriptCode, txTo, nIn, nHashType, flags); if (fOk) { isig++; nSigsCount--; } ikey++; nKeysCount--; // If there are more signatures left than keys left, // then too many signatures have failed if (nSigsCount > nKeysCount) fSuccess = false; } // Clean up stack of actual arguments while (i-- > 1) popstack(stack); // A bug causes CHECKMULTISIG to consume one extra argument // whose contents were not checked in any way. // // Unfortunately this is a potential source of mutability, // so optionally verify it is exactly equal to zero prior // to removing it from the stack. if (stack.size() < 1) return false; if ((flags & SCRIPT_VERIFY_NULLDUMMY) && stacktop(-1).size()) return error("CHECKMULTISIG dummy argument not null"); popstack(stack); stack.push_back(fSuccess ? vchTrue : vchFalse); if (opcode == OP_CHECKMULTISIGVERIFY) { if (fSuccess) popstack(stack); else return false; } } break; default: return false; } // Size limits if (stack.size() + altstack.size() > 1000) return false; } } catch (...) { return false; } if (!vfExec.empty()) return false; return true; }
Value ParseFactor() { switch (lex.token) { case T_INT: { int i = atoi(lex.sattr.c_str()); lex.Next(); return Value(i); } case T_FLOAT: { double f = atof(lex.sattr.c_str()); lex.Next(); return Value((float)f); } case T_STR: { string s = lex.sattr; lex.Next(); auto str = g_vm->NewString(s); allocated.push_back(str); return Value(str); } case T_NIL: { lex.Next(); return Value(0, V_NIL); } case T_MINUS: { lex.Next(); Value v = ParseFactor(); switch (v.type) { case V_INT: v.ival *= -1; break; case V_FLOAT: v.fval *= -1; break; default: lex.Error("numeric value expected"); } return v; } case T_LEFTBRACKET: { lex.Next(); Gobble(T_LINEFEED); vector<Value> elems; if (lex.token == T_RIGHTBRACKET) lex.Next(); else { for (;;) { elems.push_back(ParseFactor()); bool haslf = lex.token == T_LINEFEED; if (haslf) lex.Next(); if (lex.token == T_RIGHTBRACKET) break; if (!haslf) Expect(T_COMMA); } lex.Next(); } int type = -1; if (lex.token == T_COLON) { lex.Next(); string sname = lex.sattr; Expect(T_IDENT); size_t reqargs = 0; int idx = g_vm->StructIdx(sname, reqargs); if (idx >= 0) // if unknown type, becomes regular vector { // pad with NIL if current type has more fields while (elems.size() < reqargs) { elems.push_back(Value(0, V_NIL)); } // drop elements if current type has less fields while (elems.size() > reqargs) { elems.back().DEC(); elems.pop_back(); } type = idx; } } auto vec = g_vm->NewVector(elems.size(), type); allocated.push_back(vec); for (auto &e : elems) vec->push(e.INC()); return Value(vec); } default: lex.Error("illegal start of expression: " + lex.TokStr()); return Value(); } }
unsigned int push_object(const PlaneObject& obj) { objects.push_back(PlaneObjectInSpace(obj)); return objects.size()-1; }
unsigned int push_object(const PlaneObject& obj, double x, double y, double z) { objects.push_back(PlaneObjectInSpace(obj, Coordenate(x,y,z))); return objects.size()-1; }
// @@@ Note: // The only criteria we apply for these points is that they are // on or within the boundary and not too close to a corner or to // each other. However, these may not make useful triangles if // too close to an edge. Deeper in the interior may be better. // static void SetInternalVertices( vector<vertex> &vinside, vector<uint8> &map, int w, int h, const vector<lineseg> &edges, int rclear, FILE* flog ) { /* --------------------------------------------- */ /* Clear map in neighborhood of existing corners */ /* --------------------------------------------- */ int ne = edges.size(), np = w * h; for( int i = 0; i < ne; ++i ) RemoveFromMap( map, w, h, edges[i].v[0], rclear ); /* ----------------------------------- */ /* Find well-separated internal points */ /* ----------------------------------- */ for( int i = 0; i < np; ++i ) { if( map[i] ) { /* -------------------------------------------- */ /* Clear neighborhood around prospective vertex */ /* -------------------------------------------- */ int y = i / w; int x = i - w * y; fprintf( flog, "Add internal vertex at (%4d %4d).\n", x, y ); vertex newv( x, y ); RemoveFromMap( map, w, h, newv, rclear ); /* -------------------------- */ /* Apply simple 'inside' test */ /* -------------------------- */ // Make guaranteed outside point and count edge // crossings from there to proposed inside point. vertex outside( -10, y ); int m = CountCrossings( edges, newv, outside ); if( m & 1 ) vinside.push_back( newv ); else if( m ) { fprintf( flog, "Warning: Supposedly internal point is outside" " - %d crossings. Continuing.\n", m ); } } } }
unsigned int push_object(const PlaneObject& obj, const Coordenate& pos) { objects.push_back(PlaneObjectInSpace(obj, pos)); return objects.size()-1; }
// Divide bounding box B into regular array of triangles. // Fill in vector of triangles and control points. // // Return 0 always (no error). // int MeshCreateX( vector<triangle> &tri, vector<vertex> &ctl, const vector<Point> &pts, const IBox &B, FILE* flog ) { clock_t t0 = StartTiming(); tri.clear(); ctl.clear(); /* --------------- */ /* Regular spacing */ /* --------------- */ double Dx = GBL.mch.MNL, Dy = GBL.mch.MNL; int Lx = B.R - B.L, Ly = B.T - B.B, Nx, Ny; if( !Dx || Dx >= Lx ) { Nx = 1; Dx = Lx; } else { Nx = int(ceil( Lx / Dx )); Dx = Lx / Nx; } if( !Dy || Dy >= Ly ) { Ny = 1; Dy = Ly; } else { Ny = int(ceil( Ly / Dy )); Dy = Ly / Ny; } /* ----------------------------------------- */ /* Reduce tri count while Atri > GBL.mch.MTA */ /* ----------------------------------------- */ if( GBL.A.z != GBL.B.z ) { while( Nx*Ny > 1 && (Lx*Ly) / (Nx*Ny * 2) < GBL.mch.MTA ) { if( Nx >= Ny ) Dx = Lx / --Nx; else Dy = Ly / --Ny; } } /* ----------------------- */ /* Report basic grid specs */ /* ----------------------- */ fprintf( flog, "Lx Dx Nx: %5d %8.2f %3d\n", Lx, Dx, Nx ); fprintf( flog, "Ly Dy Ny: %5d %8.2f %3d\n", Ly, Dy, Ny ); /* ---------- */ /* Create ctl */ /* ---------- */ for( int iy = 0; iy <= Ny; ++iy ) { int y = (iy < Ny ? B.B + int(iy*Dy) : B.T); for( int ix = 0; ix <= Nx; ++ix ) { int x = (ix < Nx ? B.L + int(ix*Dx) : B.R); ctl.push_back( vertex( x, y ) ); } } /* ---------- */ /* Create tri */ /* ---------- */ int w = Nx + 1; for( int iy = 0; iy < Ny; ++iy ) { for( int ix = 0; ix < Nx; ++ix ) { triangle t; t.v[0] = ix + w * iy; t.v[1] = t.v[0] + 1; t.v[2] = t.v[0] + w; tri.push_back( t ); t.v[0] = t.v[2]; t.v[2] = t.v[0] + 1; tri.push_back( t ); } } /* ---------------- */ /* Remove empty tri */ /* ---------------- */ const double occ = 0.75; int ntri = tri.size(), npnt = pts.size(); // map pts into their triangles vector<int> in( ntri, 0 ); for( int i = 0; i < npnt; ++i ) { vertex v( int(pts[i].x), int(pts[i].y) ); for( int j = 0; j < ntri; ++j ) { const triangle& T = tri[j]; if( InTriangle( ctl[T.v[0]], ctl[T.v[1]], ctl[T.v[2]], v ) ) { ++in[j]; break; } } } // remove tri with low occupancy for( int i = ntri - 1; i >= 0; --i ) { const triangle& T = tri[i]; if( !in[i] || in[i] <= occ * AreaOfTriangle( ctl[T.v[0]], ctl[T.v[1]], ctl[T.v[2]] ) ) { tri.erase( tri.begin() + i ); --ntri; } } /* ----------------------- */ /* Remove unreferenced ctl */ /* ----------------------- */ if( ntri < in.size() ) { fprintf( flog, "\nOf %ld triangles, %d were above %3d%% occupancy.\n", in.size(), ntri, int(occ*100.0) ); for( int i = ctl.size() - 1; i >= 0; --i ) { for( int j = 0; j < ntri; ++j ) { const triangle& T = tri[j]; if( T.v[0] == i || T.v[1] == i || T.v[2] == i ) goto next_i; } // not ref'd ctl.erase( ctl.begin() + i ); for( int j = 0; j < ntri; ++j ) { triangle& T = tri[j]; if( T.v[0] > i ) --T.v[0]; if( T.v[1] > i ) --T.v[1]; if( T.v[2] > i ) --T.v[2]; } next_i:; } } /* ------------ */ /* Final report */ /* ------------ */ fprintf( flog, "\nSTAT: From %ld pts, got %ld triangles, %ld control points.\n", pts.size(), tri.size(), ctl.size() ); StopTiming( flog, "MeshCreate", t0 ); return 0; }
// create label for each vertex by Dijkstra algorithm on extended graphs; void HD::findPath(VertexID source, VertexID target, vector<VertexID>& path, double& d){ if (source == target) { path.push_back(source); return; } //cout << "Test: source = " << source << ", target = " << target << "." << endl; int nodesize = graph.num_vertices(); vector<double> dist (nodesize); for (int vid = 0; vid < nodesize; vid++) dist[vid] = DBL_INFINITY; dist[source] = 0.0; vector<VertexID> father(nodesize, numeric_limits<unsigned int>::max()); priority_queue<pair<double, VertexID>, vector<pair<double, VertexID> >, QueueComp> Queue; Queue.push(make_pair(0.0, source)); VertexList nodelist(nodesize); for (int vid = 0; vid < nodesize; vid++) { nodelist[vid].flaga = false; // nodelist[vid].rank = graph[vid].rank; } int i = 0; while (Queue.size() > 0) { //cout << i++ << endl; double min_dist = Queue.top().first; VertexID vid = Queue.top().second; //cout << "vid = " << vid << ", min_dist = " << min_dist << endl; Queue.pop(); if (min_dist > dist[vid]) {/*cout << "Greater!?" << endl;*/ continue;} // lazy update; else nodelist[vid].flaga = true; // settle vertex vid; if (vid == target) break; // find the target node; forall_outneighbors(graph, vid, eit){ if (nodelist[eit->target].flaga) continue; // settled; // if (/*vid != source &&*/ nodelist[eit->target].rank < nodelist[vid].rank) continue; if (dist[eit->target] > min_dist + eit->weight) { dist[eit->target] = min_dist + eit->weight; Queue.push(make_pair(dist[eit->target], eit->target)); father[eit->target] = vid; } } // forall_outshortcuts(graph, vid, eit){ // if (nodelist[eit->target].flaga) continue; // settled; // if (/*vid != source &&*/ nodelist[eit->target].rank < nodelist[vid].rank) continue; // if (dist[eit->target] > min_dist + eit->weight) { // dist[eit->target] = min_dist + eit->weight; // Queue.push(make_pair(dist[eit->target], eit->target)); // father[eit->target] = vid; // } // } } // create path information for unpacking path; vector<VertexID>(0).swap(path); path.push_back(target); int index = target; while (index != source){ if (father[index] != numeric_limits<unsigned int>::max()) { path.push_back(father[index]); index = father[index]; }else break; } if (path.size()==1) path.push_back(source); // for test; for (int i = path.size()-1; i > 0; i--){ int a = path[i]; int b = path[i-1]; forall_outneighbors(graph, a, eit){ if (eit->target == b){ d += eit->weight; break; } } } // cout << "d = " << d << endl; // cout << "father: " << endl; // for (int i = 0; i < father.size(); i++) { // cout << i << ": " << father[i] << endl; // } // cout << "~~~~~" << endl; // for (int i = path.size()-1; i >= 0; i--){ // cout << path[i] << " "; // } // cout << endl; }
void RegisterMouseControls(MouseControls* controls){ mouseControls.push_back(controls); UpdateMice(); }
void advance() { pos++; if (tape.size() <= pos) tape.push_back(0); }
void Table::getColumnReferences(Column *column, vector<TableObject *> &refs, bool exclusion_mode) { if(column && !column->isAddedByRelationship()) { unsigned count, i; IndexElement elem; Column *col=nullptr, *col1=nullptr; vector<TableObject *>::iterator itr, itr_end; bool found=false; Index *ind=nullptr; Constraint *constr=nullptr; Trigger *trig=nullptr; itr=indexes.begin(); itr_end=indexes.end(); while(itr!=itr_end && (!exclusion_mode || (exclusion_mode && !found))) { ind=dynamic_cast<Index *>(*itr); itr++; count=ind->getIndexElementCount(); for(i=0; i < count && (!exclusion_mode || (exclusion_mode && !found)); i++) { elem=ind->getIndexElement(i); col=elem.getColumn(); if(col && col==column) { found=true; refs.push_back(ind); } } } itr=constraints.begin(); itr_end=constraints.end(); while(itr!=itr_end && (!exclusion_mode || (exclusion_mode && !found))) { constr=dynamic_cast<Constraint *>(*itr); itr++; col=constr->getColumn(column->getName(),true); col1=constr->getColumn(column->getName(),false); if((col && col==column) || (col1 && col1==column)) { found=true; refs.push_back(constr); } } itr=triggers.begin(); itr_end=triggers.end(); while(itr!=itr_end && (!exclusion_mode || (exclusion_mode && !found))) { trig=dynamic_cast<Trigger *>(*itr); itr++; count=trig->getColumnCount(); for(i=0; i < count && (!exclusion_mode || (exclusion_mode && !found)); i++) { if(trig->getColumn(i)==column) { found=true; refs.push_back(trig); } } } } }
void setdesc(string wrd) {description->push_back(wrd);}
void addedge(int u,int v,int w){ es.push_back(edge(u,v,w)); g[u].push_back(es.size()-1); }
int main() { int testcases; cin >> testcases; for (int i = 0; i < testcases; i++) { int pirateland; cin >> pirateland; for (int j = 0; j < pirateland; j++) { int times; cin >> times; string land; cin >> land; for (int k = 0; k < times; k++) { for (int l = 0; l < land.size(); l++) tab.push_back((land[l] == '1')); } } sort(tab.begin(), tab.end()); root = build(0, tab.size()); int queries; cin >> queries; cout << queries << endl; int s = 1; for (int j = 0; j < queries; j++) { char l; int a, b; cin >> l >> a >> b; if (l == 'F') { cout << "F access" << endl; for (int k = a; k < b; k++) { tab[k] = true; } lazy(root, a, b); } if (l == 'E') { cout << "E access" << endl; for (int k = a; k < b; k++) { tab[k] = false; } lazy(root, a, b); } if (l == 'I') { cout << "I access" << endl; for (int k = a; k < b; k++) { tab[k] = !tab[k]; } lazy(root, a, b); //inverse pirates } if (l == 'S') { cout << "S access" << endl; propagate(root, a, b); //how many buccanneer from i to j cout << "Q" << (s++) << ": " << query(root, a, b) << endl; } for (auto s : tab) cout << s << " "; cout << endl; cout << root->r->val << endl; } } }
bool ConfigManagerImp::registerConfig(ConfigResetCallBack fun) { registerCallbacks.push_back(fun); return true; }
int main(int argc, char** argv){ srand((unsigned)time(NULL)); double min_stay_dur = 300; string file_name1 = "SampleStayRegion.txt"; string file_name3 = "RankProbability.txt"; //the input file ifstream fid_in; fid_in.open(file_name1.c_str(), ifstream::in); //the output file FILE * fout_id2; fout_id2 = fopen(file_name3.c_str(), "w"); int SSlot[96][2]={0}; string tline; double num1; double num2; double num3; double num4; double num5; int num1_int; int num2_int; int num3_int; int counter = 0; int per_count; double hour_bos; int place_count; int home_count[10000] = { 0 }; int work_count[10000] = { 0 }; int total_count[10000] = { 0 }; double place_lon[10000] = { 0 }; double place_lat[10000] = { 0 }; int home; int work; int home_num; int second_home_num; int work_num; double home_work_dist; double work_product; int week_day; int home_valid_sign; int work_valid_sign; int person_id; while (getline(fid_in, tline)){ stringstream parse_line(tline); parse_line >> num1_int >> num2_int >> num3_int >> person_id; per_count = num2_int; place_count = num3_int; for (int i = 0; i<10000; i++){ home_count[i] = 0; work_count[i] = 0; total_count[i] = 0; } counter++; //read in data and identify home and work for (int i = 0; i<per_count; i++){ getline(fid_in, tline); stringstream parse_line(tline); parse_line >> num1_int >> num2_int >> num3_int >> num4 >> num5; if (num3_int>min_stay_dur){ lons.push_back(num4); lats.push_back(num5); times.push_back(num2_int); durations.push_back(num3_int); locs.push_back(num1_int - 1); //location start with 0 hour_bos = ((num2_int % 86400) / 3600.0) - 5; if (hour_bos<0){ hour_bos += 24; } //1970/1/1 is a Thursday //From 0 to 6, Monday is 0. week_day = (int)(((num2_int - 18000) % 604800) / 86400.0) + 3; if (week_day>6){ week_day -= 7; } total_count[num1_int - 1]++; if ((hour_bos<8 || hour_bos>19) && week_day<5 || week_day>5){ home_count[num1_int - 1]++; } if (hour_bos>8 && hour_bos<19 && week_day<5){ work_count[num1_int - 1]++; } place_lon[num1_int - 1] = num4; place_lat[num1_int - 1] = num5; } } home_num = -1; work_num = -1; second_home_num = -1; home = -1; work = -1; work_product = -1; home_work_dist = -1; home_valid_sign = 0; work_valid_sign = 0; for (int i = 0; i<place_count; i++){ if (home_count[i]>home_num){ second_home_num = home_num; home_num = home_count[i]; home = i; if (home_num >= min_home_count){ home_valid_sign = 1; } } } //only one significant home location if (second_home_num > home_num * second_home_ratio){ home_valid_sign = 0; } //original criteria if (home_valid_sign == 1){ //if there are too many night departures night_departure_count = 0; for (int i = 0; i < per_count; i++){ if (locs[i]!=home){ int eslot = ((((int)(times[i] + durations[i])) - 18000) % 86400) / 900; int sday = (((int)times[i]) - 18000) / 86400; int eday = (((int)(times[i] + durations[i])) - 18000) / 86400; if (eslot > night_begin_time || sday != eday){ night_departure_count++; } } } if (night_departure_count > per_count * departure_night_ratio){ home_valid_sign = 0; continue; } counter1++; for (int i = 0; i<place_count; i++){ if (i != home && work_count[i] * distance(place_lat[home], place_lon[home], place_lat[i], place_lon[i], 'K')>work_product){ work_product = work_count[i] * distance(place_lat[home], place_lon[home], place_lat[i], place_lon[i], 'K'); work_num = work_count[i]; home_work_dist = distance(place_lat[home], place_lon[home], place_lat[i], place_lon[i], 'K'); work = i; if (work_num >= min_work_count && home_work_dist>min_home_work_dist){ work_valid_sign = 1; } else{ work_valid_sign = 0; } } } } if (!work_valid_sign){ work = -1; } else{ counter2++; } if (!home_valid_sign ){ continue; } if (place_lat[home]>min_lat && place_lat[home]<max_lat && place_lon[home]>min_lon && place_lon[home]<max_lon){ selected_home_latlon[accept_count][0]=place_lat[home]; selected_home_latlon[accept_count][1]=place_lon[home]; other_begin_end_index[accept_count][0]=other_count; ++accept_count; for (int i = 0; i<place_count; i++){ if (place_lat[i]>min_lat_big && place_lat[i]<max_lat_big && place_lon[i]>min_lon_big && place_lon[i]<max_lon_big){ if (i==home){ } else{ selected_other_latlon[other_count][0]=place_lat[i]; selected_other_latlon[other_count][1]=place_lon[i]; other_visit_count[other_count]=total_count[i]; ++other_count; } } } } if (accept_count==PERNUM){ break; } lons.clear(); lats.clear(); times.clear(); durations.clear(); locs.clear(); } for (int i=0;i<PERNUM-1;i++){ other_begin_end_index[i][1]=other_begin_end_index[i+1][0]-1; } other_begin_end_index[PERNUM][1]=other_count-1; cout<<"calculating home other distance"<<endl; double dist_sum; //distance between each home point and other location for (int i=0;i<PERNUM;i++){ if (i%100==0){ cout<<i<<endl; } dist_vec.clear(); count_vec.clear(); dist_sum=0; for (int j=0;j<other_count;j++){ double dist_ =distance(selected_home_latlon[i][0], selected_home_latlon[i][1], selected_other_latlon[j][0], selected_other_latlon[j][1], 'K'); dist_sum+=dist_; dist_vec.push_back(make_pair(dist_,j)); count_vec.push_back(make_pair(dist_,other_visit_count[j])); } sort(dist_vec.begin(),dist_vec.end(),sort_pred()); sort(count_vec.begin(),count_vec.end(),sort_pred()); int person_begin=other_begin_end_index[i][0]; int person_end=other_begin_end_index[i][1]; for (int j=0;j<other_count;j++){ if (dist_vec[j].second>=person_begin&&dist_vec[j].second<=person_end){ home_other_rank_sum[j]++; home_other_rank_sum_weighted[j]+=count_vec[j].second; home_other_rank_count++; } } } //output result for (int i=0;i<other_count;i++){ fprintf(fout_id2, "%f ", home_other_rank_sum_weighted[i]); } fprintf(fout_id2, "\n"); return 0; }
Parser(Context& ctx, string path, size_t line) : ctx(ctx), stack(vector<Syntactic_Context>()), source(0), position(0), end(0), path(path), line(line) { stack.push_back(nothing); }
int main(int argc, char **argv) { signal(SIGPIPE, SIG_IGN); setbuf(stdout, NULL); CDnsSeedOpts opts; opts.ParseCommandLine(argc, argv); nP2Port = opts.nP2Port; vSeeds.reserve(vSeeds.size() + opts.vSeeds.size()); vSeeds.insert(vSeeds.end(), opts.vSeeds.begin(), opts.vSeeds.end()); if (opts.vSeeds.empty()) { vSeeds.push_back("kjy2eqzk4zwi5zd3.onion"); vSeeds.push_back("dnsseed.bluematt.me"); vSeeds.push_back("bitseed.xf2.org"); vSeeds.push_back("dnsseed.bitcoin.dashjr.org"); vSeeds.push_back("seed.bitcoin.sipa.be"); } if (opts.tor) { CService service(opts.tor, 9050); if (service.IsValid()) { printf("Using Tor proxy at %s\n", service.ToStringIPPort().c_str()); SetProxy(NET_TOR, service); } } bool fDNS = true; if (!opts.ns) { printf("No nameserver set. Not starting DNS server.\n"); fDNS = false; } if (fDNS && !opts.host) { fprintf(stderr, "No hostname set. Please use -h.\n"); exit(1); } FILE *f = fopen("dnsseed.dat","r"); if (f) { printf("Loading dnsseed.dat..."); CAutoFile cf(f); cf >> db; if (opts.fWipeBan) db.banned.clear(); if (opts.fWipeIgnore) db.ResetIgnores(); printf("done\n"); } pthread_t threadDns, threadSeed, threadDump, threadStats; printf("Starting seeder..."); pthread_create(&threadSeed, NULL, ThreadSeeder, NULL); printf("done\n"); printf("Starting %i crawler threads...", opts.nThreads); for (int i=0; i<opts.nThreads; i++) { pthread_t thread; pthread_create(&thread, NULL, ThreadCrawler, NULL); } printf("done\n"); pthread_create(&threadDump, NULL, ThreadDumper, NULL); if (fDNS) { printf("Starting %i DNS threads for %s on %s (port %i)...", opts.nDnsThreads, opts.host, opts.ns, opts.nPort); dnsThread.clear(); for (int i=0; i<opts.nDnsThreads; i++) { dnsThread.push_back(new CDnsThread(&opts, i)); pthread_create(&threadDns, NULL, ThreadDNS, dnsThread[i]); printf("."); Sleep(20); } printf("done\n"); } pthread_create(&threadStats, NULL, ThreadStats, NULL); void* res; pthread_join(threadDump, &res); return 0; }
//--------------------------------------------------------------------------- void Init() { backbuffer = new Buffer(windowSize.x, windowSize.y); float lumScale = 1.f; Color ballDiffuse(0.1f, 0.4f, 0.4f); Color ballSpec(0.2f, 0.2f, 0.2f); Color ballEmit(0.75f, 0.75f, 0.75f); Color planeDiffuse(0.5, 0, 0); Color planeSpec(0.1f, 0.1f, 0.1f); ballEmit = lumScale * ballEmit; Color zero(0, 0, 0); #define LOAD_MESH 0 #if LOAD_MESH MeshLoader loader; loader.Load("gfx/crystals_flat.boba"); for (const protocol::MeshBlob* meshBlob : loader.meshes) { for (u32 i = 0; i < meshBlob->numIndices; i += 3) { u32 idx0 = meshBlob->indices[i + 0]; u32 idx1 = meshBlob->indices[i + 1]; u32 idx2 = meshBlob->indices[i + 2]; Vector3 p0 = { meshBlob->verts[idx0 * 3 + 0], meshBlob->verts[idx0 * 3 + 1], meshBlob->verts[idx0 * 3 + 2] }; Vector3 p1 = { meshBlob->verts[idx1 * 3 + 0], meshBlob->verts[idx1 * 3 + 1], meshBlob->verts[idx1 * 3 + 2] }; Vector3 p2 = { meshBlob->verts[idx2 * 3 + 0], meshBlob->verts[idx2 * 3 + 1], meshBlob->verts[idx2 * 3 + 2] }; tris.push_back({ p0, p1, p2 }); } } #else #if 1 int numBalls = 10; for (u32 i = 0; i < numBalls; ++i) { float angle = i * 2 * Pi / numBalls; Geo* g = new Sphere(Vector3(10 * cosf(angle), 0, 30 + 10 * sinf(angle)), 2); if (i & 1) g->material = new Material(ballDiffuse, ballSpec, zero); else g->material = new Material(ballDiffuse, ballSpec, ballEmit); objects.push_back(g); } Geo* center = new Sphere(Vector3(0, 50, 30), 15); center->material = new Material(ballDiffuse, zero, ballEmit); objects.push_back(center); #else { Geo* g = new Sphere(Vector3(-10, 10, 30), 7); g->material = new Material(ballDiffuse, ballSpec, ballEmit); objects.push_back(g); } { Geo* g = new Sphere(Vector3(0, 0, 30), 5); g->material = new Material(ballDiffuse, ballSpec, zero); objects.push_back(g); } { Geo* g = new Sphere(Vector3(10, 0, 30), 2); g->material = new Material(ballDiffuse, ballSpec, zero); objects.push_back(g); } #endif Geo* plane = new Plane(Vector3(0, 1, 0), 0); plane->material = new Material(planeDiffuse, planeSpec, zero); objects.push_back(plane); for (Geo* g : objects) { if (g->material->emissive.Max3() > 0) emitters.push_back(g); } #endif }
int Slave::getFileList(const string& path, vector<string>& filelist) { string abs_path = m_strHomeDir + path; struct stat s; if (stat(abs_path.c_str(), &s) < 0) return -1; if (!S_ISDIR(s.st_mode)) { filelist.push_back(path); return 1; } dirent **namelist; int n = scandir(abs_path.c_str(), &namelist, 0, alphasort); if (n < 0) return -1; for (int i = 0; i < n; ++ i) { // skip "." and ".." if ((strcmp(namelist[i]->d_name, ".") == 0) || (strcmp(namelist[i]->d_name, "..") == 0)) { free(namelist[i]); continue; } // check file name bool bad = false; for (char *p = namelist[i]->d_name, *q = namelist[i]->d_name + strlen(namelist[i]->d_name); p != q; ++ p) { if ((*p == 10) || (*p == 13)) { bad = true; break; } } if (bad) continue; if (stat((abs_path + "/" + namelist[i]->d_name).c_str(), &s) < 0) continue; // skip system file and directory if (S_ISDIR(s.st_mode) && (namelist[i]->d_name[0] == '.')) { free(namelist[i]); continue; } if (S_ISDIR(s.st_mode)) getFileList(path + "/" + namelist[i]->d_name, filelist); else filelist.push_back(path + "/" + namelist[i]->d_name); free(namelist[i]); } free(namelist); filelist.push_back(path); return filelist.size(); }
Value getworkex(const Array& params, bool fHelp) { if (fHelp || params.size() > 2) throw runtime_error( "getworkex [data, coinbase]\n" "If [data, coinbase] is not specified, returns extended work data.\n" ); if (vNodes.empty()) throw JSONRPCError(-9, "StealthCoin is not connected!"); if (IsInitialBlockDownload()) throw JSONRPCError(-10, "StealthCoin is downloading blocks..."); typedef map<uint256, pair<CBlock*, CScript> > mapNewBlock_t; static mapNewBlock_t mapNewBlock; static vector<CBlock*> vNewBlock; static CReserveKey reservekey(pwalletMain); if (params.size() == 0) { // Update block static unsigned int nTransactionsUpdatedLast; static CBlockIndex* pindexPrev; static int64 nStart; static CBlock* pblock; if (pindexPrev != pindexBest || (nTransactionsUpdated != nTransactionsUpdatedLast && GetTime() - nStart > 60)) { if (pindexPrev != pindexBest) { // Deallocate old blocks since they're obsolete now mapNewBlock.clear(); BOOST_FOREACH(CBlock* pblock, vNewBlock) delete pblock; vNewBlock.clear(); } nTransactionsUpdatedLast = nTransactionsUpdated; pindexPrev = pindexBest; nStart = GetTime(); // Create new block pblock = CreateNewBlock(pwalletMain); if (!pblock) throw JSONRPCError(-7, "Out of memory"); vNewBlock.push_back(pblock); } // Update nTime pblock->nTime = max(pindexPrev->GetMedianTimePast()+1, GetAdjustedTime()); pblock->nNonce = 0; // Update nExtraNonce static unsigned int nExtraNonce = 0; IncrementExtraNonce(pblock, pindexPrev, nExtraNonce); // Save mapNewBlock[pblock->hashMerkleRoot] = make_pair(pblock, pblock->vtx[0].vin[0].scriptSig); // Prebuild hash buffers char pmidstate[32]; char pdata[128]; char phash1[64]; FormatHashBuffers(pblock, pmidstate, pdata, phash1); uint256 hashTarget = CBigNum().SetCompact(pblock->nBits).getuint256(); CTransaction coinbaseTx = pblock->vtx[0]; std::vector<uint256> merkle = pblock->GetMerkleBranch(0); Object result; result.push_back(Pair("data", HexStr(BEGIN(pdata), END(pdata)))); result.push_back(Pair("target", HexStr(BEGIN(hashTarget), END(hashTarget)))); CDataStream ssTx(SER_NETWORK, PROTOCOL_VERSION); ssTx << coinbaseTx; result.push_back(Pair("coinbase", HexStr(ssTx.begin(), ssTx.end()))); Array merkle_arr; BOOST_FOREACH(uint256 merkleh, merkle) { merkle_arr.push_back(HexStr(BEGIN(merkleh), END(merkleh))); } result.push_back(Pair("merkle", merkle_arr)); return result; }
void addSuccessor(Node<T>& successor) { successors.push_back(successor); }
Tape() { pos = 0; tape.push_back(0); }
template<class T>void scan(vector<T>& a, int n, istream& cin) { T c; REP(i, n) { cin >> c; a.push_back(c); } }
//Функция выстрела void Fire(vector<Bullet> &bullet, Player & p){ Vector2f coordTurret = p.turret[1].position; bullet.push_back(Bullet(coordTurret, p.player, p.test.angle)); };