int read_file(const t_hs filename, t_glist_hs *lines) { char *data; int fd; ssize_t file_length; t_hs ths; t_glist_hs new_lines; if ((file_length = get_file_length(filename)) == -1) return (-1); if ((fd = open_file(filename, O_RDONLY)) == -1) return (-1); data = egc_malloc_atomic(file_length + 1); if (read(fd, data, file_length) == -1) { close(fd); return (-1); } close(fd); ths = hs(data); if ((int)hs_length(ths) != file_length) return (-1); new_lines = hs_split(ths, hs("\n")); glist_hs_append_all(lines, &new_lines); return (0); }
void hanoi_2(int n) { std::stack<hs> stk; stk.push(hs(n,'x','y','z')); while (!stk.empty()) { hs & top = stk.top(); switch (top.state) { case 0: if (top.n > 0) { top.state = 1; stk.push(hs(top.n-1, top.a, top.c, top.b)); } else { stk.pop(); } break; case 1: std::cout << top.a << " --> " << top.c << std::endl; top.state = 2; stk.push(hs(top.n-1, top.b, top.a, top.c)); break; case 2: stk.pop(); break; } } }
bool hs(int x,int p,int q) { printf("µ÷ÓÃhs(%d,%d,%d):\n",x,p,q); int j; for(j=1;j<=n;j++) { printf("\tj=%d,a[j]=%d,oa[j]=%d,b[j]=%d,ob[j]=%d\n",j,a[j],oa[j],b[j],ob[j]); } printf("\n"); if(p==q) { if(oa[p])return true; oa[p]=1; if(!ob[p]&&x==b[p]){ob[p]=1;return true;} return false; } else if(p+1==q) { return hs(x,p,p)||hs(x,q,q); } else { int t=(p+q)/2; if(b[t]>x)return hs(x,p,t); else return hs(x,t,q); } return false; }
std::string RepairCRC(const std::string& arData) { HexSequence hs(arData); //validate the size of the data BOOST_REQUIRE(hs.Size() >= 10); BOOST_REQUIRE(hs.Size() <= 292); //first determine how much user data is present size_t full_blocks = (hs.Size() - 10) / 18; size_t partial_size = (hs.Size() - 10) % 18; //can't have a partial size < 3 since even 1 byte requires 2 CRC bytes if(partial_size > 0) { BOOST_REQUIRE(partial_size >= 3); } //repair the header crc DNPCrc::AddCrc(hs, 8); boost::uint8_t* ptr = hs + 10; // repair the full blocks for(size_t i = 0; i < full_blocks; i++) { DNPCrc::AddCrc(ptr, 16); ptr += 18; } //repair the partial block if(partial_size > 0) DNPCrc::AddCrc(ptr, partial_size - 2); return apl::toHex(hs, hs.Size(), true); }
int _tmain(int argc, _TCHAR* argv[]) { char st[100]; printf("Input: "); gets_s(st); int *a = new int[strlen(st)]; for (int i = 0; i < strlen(st); i++) { a[i] = st[i] - '0'; } hs(a, strlen(st)); if (a[0] == 0) { for (int i = 1; i<strlen(st);i++) { if (a[i] != 0) { a[0] = a[i]; a[i] = 0; break; } } } for (int i = 0; i<strlen(st);i++) { printf("%d", a[i]); } return 0; }
void TGroup::handleEvent(TEvent &event) { TView::handleEvent(event); handleStruct hs(event, *this); if ((event.what & focusedEvents) != 0) { phase = phPreProcess; forEach(doHandleEvent, &hs); phase = phFocused; doHandleEvent(current, &hs); phase = phPostProcess; forEach(doHandleEvent, &hs); } else { phase = phFocused; if ((event.what & positionalEvents) != 0) { // get pointer to topmost view holding mouse TView *p = firstThat(hasMouse, &event); if (p) // we have a view; send event to it doHandleEvent(p, &hs); } else forEach(doHandleEvent, &hs); } }
void TGroup::handleEvent( TEvent& event ) { TView::handleEvent( event ); handleStruct hs( event, *this ); if( (event.what & focusedEvents) != 0 ) { phase = phPreProcess; forEach( doHandleEvent, &hs ); phase = phFocused; doHandleEvent( current, &hs ); phase = phPostProcess; forEach( doHandleEvent, &hs ); } else { phase = phFocused; if( (event.what & positionalEvents) != 0 ) { doHandleEvent( firstThat( hasMouse, &event ), &hs ); } else forEach( doHandleEvent, &hs ); } }
HTTPServerRequestImpl::HTTPServerRequestImpl(HTTPServerResponse& response, HTTPServerSession& session, HTTPServerParams* pParams): _response(response), _pStream(0), _pParams(pParams) { poco_check_ptr (_pParams); _pParams->duplicate(); HTTPHeaderInputStream hs(session); read(hs); // Now that we know socket is still connected, obtain addresses _clientAddress = session.clientAddress(); _serverAddress = session.serverAddress(); if (getChunkedTransferEncoding()) _pStream = new HTTPChunkedInputStream(session); else if (getContentLength() != HTTPMessage::UNKNOWN_CONTENT_LENGTH) _pStream = new HTTPFixedLengthInputStream(session, getContentLength()); else if (getMethod() == HTTPRequest::HTTP_GET || getMethod() == HTTPRequest::HTTP_HEAD) _pStream = new HTTPFixedLengthInputStream(session, 0); else _pStream = new HTTPInputStream(session); }
Example::Example(bool scrbars, MySpriteField& sfield, QWidget* parent, const char* name, WFlags f) : QWidget(parent,name?name:"example",f), field(sfield), view(scrbars ? (QWidget*)new QwScrollingSpriteFieldView(&field,this) : (QWidget*)new QwSpriteFieldView(&field,this) ), sprite(0), textsprite("QwTextSprite",QFont("Helvetica",18)), scrollbars(scrbars), count(0) { setMouseTracking(TRUE); view->move(0,0); textsprite.setColor(red); if (!btext) textsprite.hide(); QPixmap pm(63,63); pm.fill(black); QPainter p; p.begin(&pm); for (int i=0; i<50; i++) { p.setPen(QColor(rand()%255,rand()%255,rand()%255)); p.drawLine(rand()%62,rand()%62,rand()%62,rand()%62); } p.setPen(white); p.drawText(0,0,63,63,AlignCenter,"DRAWN\nSPRITE"); pm.setMask(pm.createHeuristicMask()); p.end(); QPoint hs(31,31); QList<QPixmap> lpm; lpm.append(&pm); QList<QPoint> lhs; lhs.append(&hs); drawnsprite = new QwSprite( new QwSpritePixmapSequence(lpm,lhs) ); // Diamond QPointArray pa(4); pa[0] = QPoint(0,-150); pa[1] = QPoint(+150,0); pa[2] = QPoint(0,+150); pa[3] = QPoint(-150,0); polygon = new QwPolygon(); polygon->setBrush(DiagCrossPattern); polygon->setBrush(QBrush(red,DiagCrossPattern)); polygon->setPoints(pa); images=new QwSpritePixmapSequence( IMG_SPRITE_DATA, IMG_SPRITE_MASK, NR_ROTS); setCount(bouncers); resize(WIDTH,HEIGHT); // Since it is virtual, ours won't be called in the constructor refresh(); resizeEvent(0); startTimer(refresh_delay); timer.start(); }
bool DBManager::existsRequest(std::string card) { bool res = false; std::string selectQuery = std::string("SELECT COUNT(*) FROM ACCOUNT " "WHERE card = \"") + card + std::string("\";"); sqlite3_stmt * getStmt; int ret = 0; if (SQLITE_OK != (ret = sqlite3_prepare(database, selectQuery.c_str(), selectQuery.size(), &getStmt, NULL))) { std::cout << "Failed to prepare select statement" << std::endl; } if (SQLITE_ROW != (ret = sqlite3_step(getStmt))) { std::cout << "Failed to step select" << std::endl; } std::istringstream hs(reinterpret_cast<const char*>(sqlite3_column_text(getStmt, 0))); int count; hs >> count; if (count != 0) { res = true; } return res; }
int main(){ int n; char c; char cs[1002]; scanf("%d",&n); for(int i=0;i<n;i++){ scanf("%s",cs); for(int j=0;j<n;j++){ if(cs[j]=='.'){ inp[i][j]=0; } else { inp[i][j]=1; } } } hs(n); d1s1(n); for(int l=0;l<n;l++){ for(int m=0;m<n;m++){ printf("%d",inp[l][m]); if(m<n-1){ printf("%c",' '); } } printf("%c",'\n'); } }
int main(int argc, char *argv[]) { char *cmd; int res; set_dlog_level (L_DBG); if ((cmd = strrchr(argv[0], '/')) == NULL) cmd = argv[0]; else cmd++; if (strcmp(cmd, "hmsg_monitor") == 0) { str_hash_init(HASH_FILE); str_hash_dump(); dlog(L_INFO, "start hmsg_monitor\n"); hmsg_monitor(); return 0; } else if (strcmp(cmd, "hs") == 0) { res = hs(argc, argv); } else { dlog(L_ERR, "Invalid command\n"); usage(); res = -1; } return res; }
Region* buildRegion2( vector< vector<Point> >& cycles){ //cout << "buildRegion2 called wth " << cycles.size() << " cycles " << endl; Line* hss = new Line(80); hss->StartBulkLoad(); int edgeno = 0; for(size_t c = 0; c<cycles.size(); c++){ for(size_t i=0;i<cycles[c].size()-1; i++){ HalfSegment hs(true, cycles[c][i],cycles[c][i+1]); hs.attr.edgeno = edgeno; (*hss) += hs; hs.SetLeftDomPoint(!hs.IsLeftDomPoint()); (*hss) += hs; edgeno++; } } hss->EndBulkLoad(); Region* res= new Region(hss->Size()); hss->Transform(*res); hss->DeleteIfAllowed(); return res; }
void addRegion(vector<pair<Region*, bool> > & regs, vector<Point>& cycle){ bool isFace = getDir(cycle); if(cycle.size()<2){ return; } if(!AlmostEqual(cycle[0],cycle[cycle.size()-1])){ // cycle not closed } if(cycle.size() < 4){ return; } Line* hss = new Line(cycle.size()*2); hss->StartBulkLoad(); for(size_t i = 0; i<cycle.size()-1; i++){ HalfSegment hs(true, cycle[i],cycle[i+1]); hs.attr.edgeno = i; (*hss) += hs; hs.SetLeftDomPoint(!hs.IsLeftDomPoint()); (*hss) += hs; } hss->EndBulkLoad(); Region* res= new Region(cycle.size()*2); hss->Transform(*res); hss->DeleteIfAllowed(); regs.push_back(pair<Region*,bool>(res, isFace)); }
void MasterTestObject::SendUnsolToMaster(const std::string& arData) { HexSequence hs(arData); mAPDU.Reset(); mAPDU.Write(hs, hs.Size()); mAPDU.Interpret(); master.OnUnsolResponse(mAPDU); }
REP( i, N ) { x = X[i] + dx; y = Y[i] + dy; if ( x < 0 || x >= MAXC || y < 0 || y >= MAXC ) continue; hs( dx, dy ) += haystack[x][y]; }
void SurfaceHeight<EvalT, Traits>:: evaluateFields(typename Traits::EvalData workset) { if (memoizer_.haveStoredData(workset)) return; #ifndef ALBANY_KOKKOS_UNDER_DEVELOPMENT switch (hs_type) { case NONE: //no surface height: hs = 0 for (int cell=0; cell < workset.numCells; ++cell) { for (int qp=0; qp < numQPs; ++qp) hs(cell,qp) = 0.0; } break; case MOUNTAIN: //surface height for test case 5 const double R = pi/9.0; const double lambdac = 1.5*pi; const double thetac = pi/6.0; for (int cell=0; cell < workset.numCells; ++cell) { for (int qp = 0; qp < numQPs; ++qp) { MeshScalarT lambda = sphere_coord(cell,qp,0); MeshScalarT theta = sphere_coord(cell,qp,1); MeshScalarT radius2 = (lambda-lambdac)*(lambda-lambdac) + (theta-thetac)*(theta-thetac); //r^2 = min(R^2, (lambda-lambdac)^2 + (theta-thetac)^2); MeshScalarT r; if (radius2 > R*R) r = R; else r = sqrt(radius2); //hs = hs0*(1-r/R) for test case 5 hs(cell,qp) = hs0*(1.0-r/R); } } break; } #else switch (hs_type) { case NONE: Kokkos::parallel_for(SurfaceHeight_Policy(0,workset.numCells),*this); break; case MOUNTAIN: Kokkos::parallel_for(SurfaceHeight_MOUNTAIN_Policy(0,workset.numCells),*this); break; } #endif }
void AsyncSlaveTestObject::SendToSlave(const std::string& arData, SequenceInfo aSeq) { HexSequence hs(arData); mAPDU.Reset(); mAPDU.Write(hs, hs.Size()); mAPDU.Interpret(); LOG_BLOCK(LEV_INTERPRET, "<= " << mAPDU.ToString()); slave.OnRequest(mAPDU, aSeq); }
void MasterTestObject::RespondToMaster(const std::string& arData, bool aFinal) { HexSequence hs(arData); mAPDU.Reset(); mAPDU.Write(hs, hs.Size()); mAPDU.Interpret(); if(aFinal) master.OnFinalResponse(mAPDU); else master.OnPartialResponse(mAPDU); }
void MockPhysicalLayerAsync::TriggerRead(const std::string& arData) { HexSequence hs(arData); assert(hs.Size() <= this->mNumToRead); memcpy(mpWriteBuff, hs.Buffer(), hs.Size()); mNumToRead = 0; error_code ec(errc::success, get_generic_category()); this->OnReadCallback(ec, mpWriteBuff, hs.Size()); }
am_status_t BaseService::sendRequest(Connection& conn, const BodyChunk& headerPrefix, const std::string& uri, const std::string& uriParameters, const Http::HeaderList& headerList, const Http::CookieList& cookieList, const BodyChunk& contentLine, const BodyChunk& headerSuffix, const BodyChunkList& bodyChunkList) const { Connection::ConnHeaderMap hdrs; size_t hListSize = headerList.size(); Http::Cookie theCookie; for (size_t idx = 0; idx < hListSize; idx++) { std::string headerLine; theCookie = headerList[idx]; headerLine.append(theCookie.name); headerLine.append(": "); headerLine.append(theCookie.value); hdrs.insert(Connection::ConnHeaderMapValue(headerLine, "")); } size_t listSize = cookieList.size(); if (listSize > 0) { std::string cookieLine("Cookie: "); for (size_t iii = 0; iii < listSize; iii++) { theCookie = cookieList[iii]; cookieLine.append(theCookie.name); cookieLine.append("="); cookieLine.append(theCookie.value); if (iii != listSize - 1) { cookieLine.append(";"); } } hdrs.insert(Connection::ConnHeaderMapValue(cookieLine, "")); } std::string hsorig(headerSuffix.data); hsorig.erase(hsorig.size() - 2); std::stringstream hs(hsorig); std::string line; while (std::getline(hs, line)) { if (line != "") hdrs.insert(Connection::ConnHeaderMapValue(line, "")); } std::string body; for (std::size_t i = 0; i < bodyChunkList.size(); ++i) { body.append(bodyChunkList[i].data); } std::string u(uri + uriParameters); return conn.sendRequest(headerPrefix.data.c_str(), u, hdrs, body); }
static t_result lex_token(const char **string_p) { t_result result; result = lex_token_impl(string_p); if (result.token || result.error) return (result); result = lex_word(string_p); if (result.token || result.error) return (result); return (RESULT_ERROR(hs("Unexpected character"), *string_p)); }
bool IsFrameEqual(LinkFrame& frame, const std::string& arData) { HexSequence hs(arData); if(frame.GetSize() != hs.Size()) return false; boost::uint8_t* buff = frame.GetBuffer(); for(size_t i = 0; i < hs.Size(); i++) { if(buff[i] != hs[i]) return false; } return true; }
static t_hs parser_setup_pipeline(t_node *node) { int i; t_node *child; int pipefd[2]; i = 0; while (i < glist_voidp_length(&node->children)) { child = glist_voidp_get(&node->children, i); if (i) child->redir.input = pipefd[0]; if ((i + 1) < glist_voidp_length(&node->children)) { if (pipe(pipefd)) return (hs("pipe() error")); child->redir.output = pipefd[1]; } i++; } return (hs("")); }
Num solve_Sss(Num X, Num T, Num r, Num b, Num v) { Num N = 2 * b / (v * v); Num M = 2 * r / (v * v); Num Sj = seed_Sss(N, M, X, T, b, v); Num K = 1 - exp(-r * T); Num d1 = bsm_general::d1(Sj, X, T, b, v); Num q1_ = q1(N, M, K); Num VS = X - Sj; Num HS = hs(d1, Sj, X, T, r, b, v, q1_); Num bj_ = bj(d1, T, r, b, v, q1_); Num eps = 1e-6; while (std::abs(VS - HS) / X > eps) { Sj = (X - HS + bj_ * Sj) / (1 + bj_); d1 = bsm_general::d1(Sj, X, T, b, v); VS = X - Sj; HS = hs(d1, Sj, X, T, r, b, v, q1_); bj_ = bj(d1, T, r, b, v, q1_); } return Sj; }
bool Parse( Furrovine::String filename ) { class ASTDeclConsumer : public clang::ASTConsumer { public: ASTDeclConsumer( std::vector<clang::Decl*>& arg ) : vec( arg ) {} std::vector<clang::Decl*>& vec; bool HandleTopLevelDecl( clang::DeclGroupRef arg ) { for ( auto && x : arg ) { vec.push_back( x ); } return true; } }; ASTDeclConsumer astconsumer( declarations ); llvm::StringRef llvmfilename( reinterpret_cast<char*>( filename.data( ) ) ); clang::CompilerInstance ci; clang::DiagnosticsEngine diagnosticsengine( diagnosticids, llvmdiagnosticsoptions.getPtr(), new clang::TextDiagnosticPrinter( errorstream, llvmdiagnosticsoptions.getPtr(), false ), true ); clang::FileManager filemanager( filesystemoptions ); clang::SourceManager sourcemanager( diagnosticsengine, filemanager ); std::unique_ptr<clang::TargetInfo> targetinfo( clang::TargetInfo::CreateTargetInfo( diagnosticsengine, &targetoptions ) ); targetinfo->setCXXABI( clang::TargetCXXABI::Microsoft ); clang::HeaderSearchOptions& headersearchoptions = *llvmheadersearchoptions; clang::HeaderSearch hs( llvmheadersearchoptions, filemanager, diagnosticsengine, languageoptions, targetinfo.get( ) ); clang::PreprocessorOptions& preprocessoroptions = *llvmpreprocessoroptions; clang::Preprocessor preprocessor( llvmpreprocessoroptions, diagnosticsengine, languageoptions, targetinfo.get( ), sourcemanager, hs, ci ); clang::InitializePreprocessor( preprocessor, preprocessoroptions, headersearchoptions, frontendoptions ); preprocessor.getBuiltinInfo( ).InitializeBuiltins( preprocessor.getIdentifierTable( ), languageoptions ); clang::ASTContext astcontext( languageoptions, sourcemanager, targetinfo.get( ), preprocessor.getIdentifierTable( ), preprocessor.getSelectorTable( ), preprocessor.getBuiltinInfo( ), 1024 ); clang::Sema sema( preprocessor, astcontext, astconsumer, clang::TU_Complete, null ); const clang::DirectoryLookup* directlookup = nullptr; auto entry = hs.LookupFile( llvmfilename, true, nullptr, directlookup, nullptr, nullptr, nullptr, nullptr ); if ( !entry ) entry = filemanager.getFile( llvmfilename ); if ( !entry ) throw Furrovine::TException<std::exception>( "Could not find file " + filename ); auto fileid = sourcemanager.createFileID( entry, clang::SourceLocation( ), clang::SrcMgr::CharacteristicKind::C_User ); if ( fileid.isInvalid( ) ) throw Furrovine::TException<std::exception>( "Error translating file " + filename ); sourcemanager.setMainFileID( fileid ); diagnosticsengine.getClient( )->BeginSourceFile( languageoptions, &preprocessor ); clang::ParseAST( sema ); diagnosticsengine.getClient( )->EndSourceFile( ); return diagnosticsengine.getClient( )->getNumErrors() == 0; }
static t_hs get_hostname(void) { int fd; char c; t_hs host; host = hs(""); if ((fd = open_file(hs("/etc/hostname"), O_RDONLY)) == -1) return (hs("42sh")); while (42) { if (read(fd, &c, 1) == -1) { close(fd); return (hs("42sh")); } if (c == '\n' || c == '\0') break ; host = hs_concat_hs_char(host, c); } close(fd); return (host); }
void ResponseLoaderTestObject::Load(const std::string& arAPDU) { fdo.Clear(); HexSequence hs(arAPDU); APDU f; f.Write(hs, hs.Size()); f.Interpret(); ResponseLoader rl(mpLogger, &fdo); for(HeaderReadIterator hdr = f.BeginRead(); !hdr.IsEnd(); ++hdr) { rl.Process(hdr); } }
KOKKOS_INLINE_FUNCTION void SurfaceHeight<EvalT, Traits>:: operator() (const SurfaceHeight_MOUNTAIN_Tag& tag, const int& cell) const{ const double R = pi/9.0; const double lambdac = 1.5*pi; const double thetac = pi/6.0; for (int qp = 0; qp < numQPs; ++qp) { MeshScalarT lambda = sphere_coord(cell,qp,0); MeshScalarT theta = sphere_coord(cell,qp,1); MeshScalarT radius2 = (lambda-lambdac)*(lambda-lambdac) + (theta-thetac)*(theta-thetac); //r^2 = min(R^2, (lambda-lambdac)^2 + (theta-thetac)^2); MeshScalarT r; if (radius2 > R*R) r = R; else r = sqrt(radius2); hs(cell,qp) = hs0*(1.0-r/R); } }
typename heat::HeatKernelSignature<PointT>::HeatSignature heat::HeatKernelSignature<PointT>::compute(const int x, const double t, const int n_functions) { HeatSignature hs(new std::vector<double>(_cloud->size())); for (int y = 0; y < _cloud->size(); y++) { double sum = 0.0; for (int j = 0; j < n_functions; j++) { double lambda = _eigenvalue(j); Eigen::VectorXd psi = _eigenfunctions.col(j); sum += exp(-lambda * t) * psi(x) * psi(y); } hs->at(y) = sum; } return hs; }