const Matrix & ElasticBeam2d::getTangentStiff(void) { const Vector &v = theCoordTransf->getBasicTrialDisp(); double L = theCoordTransf->getInitialLength(); double EoverL = E/L; double EAoverL = A*EoverL; // EA/L double EIoverL2 = 2.0*I*EoverL; // 2EI/L double EIoverL4 = 2.0*EIoverL2; // 4EI/L // determine q = kv + q0 q(0) = EAoverL*v(0); q(1) = EIoverL4*v(1) + EIoverL2*v(2); q(2) = EIoverL2*v(1) + EIoverL4*v(2); q(0) += q0[0]; q(1) += q0[1]; q(2) += q0[2]; kb(0,0) = EAoverL; kb(1,1) = kb(2,2) = EIoverL4; kb(2,1) = kb(1,2) = EIoverL2; return theCoordTransf->getGlobalStiffMatrix(kb, q); }
const Matrix& TwoNodeLink::getTangentStiff() { // zero the matrix theMatrix->Zero(); // get resisting forces and stiffnesses Matrix kb(numDir,numDir); for (int i=0; i<numDir; i++) { qb(i) = theMaterials[i]->getStress(); kb(i,i) = theMaterials[i]->getTangent(); } // transform from basic to local system Matrix kl(numDOF,numDOF); kl.addMatrixTripleProduct(0.0, Tlb, kb, 1.0); // add geometric stiffness to local stiffness if (Mratio.Size() == 4) this->addPDeltaStiff(kl); // transform from local to global system theMatrix->addMatrixTripleProduct(0.0, Tgl, kl, 1.0); //Matrix kg(numDOF,numDOF); //kg.addMatrixTripleProduct(0.0, Tgl, kl, 1.0); //theMatrix->addMatrixTranspose(0.5, kg, 0.5); return *theMatrix; }
void mexFunction(int nlhs, mxArray *plhs[], /* Output variables */ int nrhs, const mxArray *prhs[]) /* Input variables */ { #define ccr(ai,bi) (ccr[ai+Nss[0]*bi]) #define cci(ai,bi) (cci[ai+Nss[0]*bi]) #define kk1(ai,bi) (kk1[ai+Nss[0]*bi]) #define kk2(ai,bi) (kk2[ai+Nss[0]*bi]) #define kb(loc1,loc2,ai,bi) kb[loc1+NB1*(loc2+NB2*(ai+Nss[0]*bi))] #define avgdx(loc1,loc2,ai,bi) avgdx[loc1+NB1*(loc2+NB2*(ai+Nss[0]*bi))] #define avgdy(loc1,loc2,ai,bi) avgdy[loc1+NB1*(loc2+NB2*(ai+Nss[0]*bi))] size_t ai, bi; int NB1, NB2, loc1, loc2, di = 0; double *kk1, *kk2, *ccr, *cci, *kb, *avgdx, *avgdy; double EXT, num_dir, da, dr, r, agl, R_low; double temp_energy; ccr = mxGetPr(prhs[0]); cci = mxGetPi(prhs[0]); kk1 = mxGetPr(prhs[1]); kk2 = mxGetPr(prhs[2]); EXT = mxGetScalar(prhs[3]); num_dir = mxGetScalar(prhs[4]); da = mxGetScalar(prhs[5]); dr = mxGetScalar(prhs[6]); NB1 = mxGetScalar(prhs[7]); NB2 = mxGetScalar(prhs[8]); R_low = mxGetScalar(prhs[9]); const mwSize *Nss = mxGetDimensions(prhs[0]); kb = mxGetPr(prhs[10]); avgdx = mxGetPr(prhs[11]); avgdy = mxGetPr(prhs[12]); nrhs = 13; nlhs = 0; for (ai=0;ai<Nss[0];ai++) { for (bi=0;bi<Nss[1];bi++) { if (kk1(ai,bi)<EXT) { r = sqrt(kk1(ai,bi)*kk1(ai,bi)+kk2(ai,bi)*kk2(ai,bi)); if (kk1(ai,bi)>=0) { agl = fmod(acos(kk2(ai,bi)/r),num_dir); } else agl = fmod(3.1415926-acos(kk2(ai,bi)/r),num_dir); loc1 = round((r-R_low)/dr); loc2 = round(agl/da); temp_energy = ccr(ai,bi)*ccr(ai,bi) + cci(ai,bi)*cci(ai,bi); kb(loc1,loc2,ai,bi) = kb(loc1,loc2,ai,bi) + temp_energy; avgdx(loc1,loc2,ai,bi) = avgdx(loc1,loc2,ai,bi) + r * cos(agl) * temp_energy; avgdy(loc1,loc2,ai,bi) = avgdy(loc1,loc2,ai,bi) + r * sin(agl) * temp_energy; /* cannot use kk since those are symmetric */ } } } return; }
static void prquota(struct mnttab *mntp, struct dqblk *dqp) { struct timeval tv; char ftimeleft[80], btimeleft[80]; char *cp; time(&(tv.tv_sec)); tv.tv_usec = 0; if (dqp->dqb_bsoftlimit && dqp->dqb_curblocks >= dqp->dqb_bsoftlimit) { if (dqp->dqb_btimelimit == 0) { strcpy(btimeleft, "NOT STARTED"); } else if (dqp->dqb_btimelimit > tv.tv_sec) { fmttime(btimeleft, dqp->dqb_btimelimit - tv.tv_sec); } else { strcpy(btimeleft, "EXPIRED"); } } else { btimeleft[0] = '\0'; } if (dqp->dqb_fsoftlimit && dqp->dqb_curfiles >= dqp->dqb_fsoftlimit) { if (dqp->dqb_ftimelimit == 0) { strcpy(ftimeleft, "NOT STARTED"); } else if (dqp->dqb_ftimelimit > tv.tv_sec) { fmttime(ftimeleft, dqp->dqb_ftimelimit - tv.tv_sec); } else { strcpy(ftimeleft, "EXPIRED"); } } else { ftimeleft[0] = '\0'; } if (strlen(mntp->mnt_mountp) > 12) { printf("%s\n", mntp->mnt_mountp); cp = ""; } else { cp = mntp->mnt_mountp; } printf("%-12.12s %7d %6d %6d %11s %6d %6d %6d %11s\n", cp, kb(dqp->dqb_curblocks), kb(dqp->dqb_bsoftlimit), kb(dqp->dqb_bhardlimit), btimeleft, dqp->dqb_curfiles, dqp->dqb_fsoftlimit, dqp->dqb_fhardlimit, ftimeleft); }
DEVICE_INPUT_DEFAULTS_END void cardinal_state::cardinal(machine_config &config) { i8031_device &maincpu(I8031(config, "maincpu", 7.3728_MHz_XTAL)); maincpu.set_addrmap(AS_PROGRAM, &cardinal_state::prog_map); maincpu.set_addrmap(AS_IO, &cardinal_state::ext_map); maincpu.port_in_cb<1>().set(FUNC(cardinal_state::p1_r)); maincpu.port_out_cb<1>().set(FUNC(cardinal_state::p1_w)); maincpu.port_in_cb<3>().set_ioport("P3"); EEPROM_93C06_16BIT(config, m_eeprom); CRT9028_000(config, m_vtlc, 10.92_MHz_XTAL); m_vtlc->set_screen("screen"); m_vtlc->set_addrmap(0, &cardinal_state::ram_map); m_vtlc->vsync_callback().set_inputline("maincpu", MCS51_INT0_LINE).invert(); SCREEN(config, "screen", SCREEN_TYPE_RASTER); SPEAKER(config, "mono").front_center(); SPEAKER_SOUND(config, m_speaker).add_route(ALL_OUTPUTS, "mono", 0.05); RS232_PORT(config, m_rs232, default_rs232_devices, nullptr); rs232_port_device &kb(RS232_PORT(config, "kb", default_rs232_devices, "keyboard")); kb.set_option_device_input_defaults("keyboard", DEVICE_INPUT_DEFAULTS_NAME(keyboard)); kb.rxd_handler().set_inputline("maincpu", MCS51_INT1_LINE).invert(); }
const Matrix & ElasticBeam2d::getInitialStiff(void) { double L = theCoordTransf->getInitialLength(); double EoverL = E/L; double EAoverL = A*EoverL; // EA/L double EIoverL2 = 2.0*I*EoverL; // 2EI/L double EIoverL4 = 2.0*EIoverL2; // 4EI/L kb(0,0) = EAoverL; kb(1,1) = kb(2,2) = EIoverL4; kb(2,1) = kb(1,2) = EIoverL2; return theCoordTransf->getInitialGlobalStiffMatrix(kb); }
ndt::type resolve(base_callable *caller, char *DYND_UNUSED(data), call_graph &cg, const ndt::type &dst_tp, size_t DYND_UNUSED(nsrc), const ndt::type *src_tp, size_t nkwd, const array *kwds, const std::map<std::string, ndt::type> &tp_vars) { cg.emplace_back([](kernel_builder &kb, kernel_request_t kernreq, char *DYND_UNUSED(data), const char *dst_arrmeta, size_t nsrc, const char *const *src_arrmeta) { size_t self_offset = kb.size(); kb.emplace_back<forward_na_kernel<I...>>(kernreq); kb(kernel_request_single, nullptr, dst_arrmeta, nsrc, src_arrmeta); for (intptr_t i : std::array<index_t, sizeof...(I)>({I...})) { size_t is_na_offset = kb.size() - self_offset; kb(kernel_request_single, nullptr, nullptr, 1, src_arrmeta + i); kb.get_at<forward_na_kernel<I...>>(self_offset)->is_na_offset[i] = is_na_offset; } size_t assign_na_offset = kb.size() - self_offset; kb(kernel_request_single, nullptr, nullptr, 0, nullptr); kb.get_at<forward_na_kernel<I...>>(self_offset)->assign_na_offset = assign_na_offset; }); ndt::type src_value_tp[2]; for (intptr_t i = 0; i < 2; ++i) { src_value_tp[i] = src_tp[i]; } for (intptr_t i : std::array<index_t, sizeof...(I)>({I...})) { src_value_tp[i] = src_value_tp[i].extended<ndt::option_type>()->get_value_type(); } base_callable *child; if (m_child.is_null()) { child = caller; } else { child = m_child.get(); } ndt::type res_value_tp = child->resolve(this, nullptr, cg, dst_tp.is_symbolic() ? child->get_ret_type() : dst_tp, 2, src_value_tp, nkwd, kwds, tp_vars); for (index_t i : std::array<index_t, sizeof...(I)>({I...})) { is_na->resolve(this, nullptr, cg, ndt::make_type<bool>(), 1, src_tp + i, 0, nullptr, tp_vars); } return assign_na->resolve(this, nullptr, cg, ndt::make_type<ndt::option_type>(res_value_tp), 0, nullptr, nkwd, kwds, tp_vars); }
int main() { KoalaBot kb("Marcos"); std::cout << std::boolalpha << kb.status() << std::endl; kb.informations(); return 0; }
std::string LibES::GetString (const std::string& aHeader, const std::string& aMessage) { #ifndef HAVE_ESSUB_GETSTRING Keyboard kb(Area(10, 10, 80, 80), aHeader, aMessage); Summerface("Keyboard", &kb, false).Do(); return kb.GetText(); #else return LibESPlatform::GetString(aHeader, aMessage); #endif }
void kJsonProtocolBase::fromBuffer(const unsigned char* pbuffer,unsigned int bufflen) { // alloc size here first,if not alloc,it will alloc each time when not enough kByteBuffer kb(bufflen); kb.putBytes(pbuffer, bufflen); kb.getShort(); unsigned char buf[bufflen - sizeof(short)]; kb.getBytes(buf, bufflen - sizeof(short)); fromJson(std::string((char*)buf)); }
void Font::renderBillboardText( const std::string& text, const vec3f& pos, float fontHeight, vec3f cameraK, const Color4f& color, const vec2f& relPos, bool fixedWidth ) { vec3f kb( cameraK ); kb.normalize(); vec3f ib( vec3f( 0.0f, 1.0f, 0.0f ).cross( kb ) ); ib.normalize(); vec3f jb( kb.cross( ib ) ); jb.normalize(); render3DText( text, pos, fontHeight, ib, jb, color, relPos, fixedWidth ); }
const Matrix & ModElasticBeam2d::getInitialStiff(void) { double L = theCoordTransf->getInitialLength(); double EoverL = E/L; double EAoverL = A*EoverL; // EA/L double EIoverL2 = K44*I*EoverL; // 2EI/L double EIoverL4 = K11*I*EoverL; // 4EI/L // Added By Dimitrios Lignos double EIoverL6 = K33*I*EoverL; // 4EI/L kb(0,0) = EAoverL; kb(1,1) = EIoverL4; //kb(2,2) = EIoverL4; kb(2,2) = EIoverL6; kb(2,1) = kb(1,2) = EIoverL2; return theCoordTransf->getInitialGlobalStiffMatrix(kb); }
int main() { kb(); kb2(); kb3(); Activity4(); ActivitiesnextDate1(); ActivitiesnextDate2(); activitiesExist(); Activities_test_slot_function(); return unit_test::report_errors(); }
void kJsonProtocolBase::sendToJavaServer(kSocket& sock) { if(!sock)return; std::string buff = toJson(); unsigned short _data_len = buff.size();// for json string length unsigned short swaped = _data_len; kByteBuffer::endian_swap_s(&swaped); kByteBuffer kb(_data_len + sizeof(unsigned short));// 2 for length // kByteBuffer kb(_data_len); kb.putShort(swaped); kb.putBytes(kCipher::encryptBuffer((unsigned char*)buff.c_str(), buff.size()),buff.size()); sock.send_to((char*)kb.getContent(), _data_len + 2); }
void kJsonProtocolBase::fromBufferDecryptJavaServer(const unsigned char* pbuffer,unsigned int bufflen) { // alloc size here first,if not alloc,it will alloc each time when not enough kByteBuffer kb(bufflen); kb.putBytes(pbuffer, bufflen); kb.toSmallEndian(); kb.getShort(); int datalen = bufflen - sizeof(short); unsigned char buf[datalen]; kb.getBytes(buf, datalen); kCipher::decryptBuffer(buf, datalen); fromJson(std::string((char*)buf)); }
const Matrix & ZeroLengthND::getTangentStiff(void) { // Compute material strains this->computeStrain(); // Set trial strain for NDMaterial theNDMaterial->setTrialStrain(*v); // Get NDMaterial tangent, the element basic stiffness const Matrix &kb = theNDMaterial->getTangent(); // Set some references to make the syntax nicer Matrix &stiff = *K; const Matrix &tran = *A; stiff.Zero(); double E; // Compute element stiffness ... K = A^*kb*A for (int k = 0; k < order; k++) { for (int l = 0; l < order; l++) { E = kb(k,l); for (int i = 0; i < numDOF; i++) for (int j = 0; j < i+1; j++) stiff(i,j) += tran(k,i) * E * tran(l,j); } } if (the1DMaterial != 0) { // Set trial strain for UniaxialMaterial the1DMaterial->setTrialStrain(e); // Get UniaxialMaterial tangent, the element basic stiffness E = the1DMaterial->getTangent(); // Compute element stiffness ... K = A^*kb*A for (int i = 0; i < numDOF; i++) for (int j = 0; j < i+1; j++) stiff(i,j) += tran(2,i) * E * tran(2,j); } // Complete symmetric stiffness matrix for (int i = 0; i < numDOF; i++) for(int j = 0; j < i; j++) stiff(j,i) = stiff(i,j); return stiff; }
const Matrix & ElasticBeam3d::getTangentStiff(void) { const Vector &v = theCoordTransf->getBasicTrialDisp(); double L = theCoordTransf->getInitialLength(); double oneOverL = 1.0/L; double EoverL = E*oneOverL; double EAoverL = A*EoverL; // EA/L double EIzoverL2 = 2.0*Iz*EoverL; // 2EIz/L double EIzoverL4 = 2.0*EIzoverL2; // 4EIz/L double EIyoverL2 = 2.0*Iy*EoverL; // 2EIy/L double EIyoverL4 = 2.0*EIyoverL2; // 4EIy/L double GJoverL = G*Jx*oneOverL; // GJ/L q(0) = EAoverL*v(0); q(1) = EIzoverL4*v(1) + EIzoverL2*v(2); q(2) = EIzoverL2*v(1) + EIzoverL4*v(2); q(3) = EIyoverL4*v(3) + EIyoverL2*v(4); q(4) = EIyoverL2*v(3) + EIyoverL4*v(4); q(5) = GJoverL*v(5); q(0) += q0[0]; q(1) += q0[1]; q(2) += q0[2]; q(3) += q0[3]; q(4) += q0[4]; kb(0,0) = EAoverL; kb(1,1) = kb(2,2) = EIzoverL4; kb(2,1) = kb(1,2) = EIzoverL2; kb(3,3) = kb(4,4) = EIyoverL4; kb(4,3) = kb(3,4) = EIyoverL2; kb(5,5) = GJoverL; return theCoordTransf->getGlobalStiffMatrix(kb,q); }
void main(void) { char c; do { clrscr(); window(25,5,54,12); textbackground(7); textcolor(3); clrscr(); window(25,5,54,20); gotoxy(1,1); createwin(); textcolor(0); window(26,6,53,13); gotoxy(1,3); cputs(" Запись в файл\n\r"); cputs(" Обработка файла\n\r"); cputs(" cортировка по Алфавиту\n\r"); cputs(" сортировка по Dлине\n\r"); cputs(" Просмотр файла\n\r"); cputs(" Выход\n\r"); textbackground(0); window(1,1,80,25); gotoxy(23,1); textcolor(15); cputs("КУРСОВАЯ РАБОТА ПО ПРОГРАММИРОВАНИЮ"); gotoxy(29,24); cputs("(C) ПАВЕЛ СКРЫЛЕВ 1995"); c=getch(); switch (c) { case 'c':enter(); break; case 'g':look(); break; case 'f':alf(); break; case 'l':length(); break; case 'j':kb(); break; } } while(c!='d'); clrscr(); cputs("Course work for a course of Programming by Skrylev Pavel (C)1995"); }
const Matrix & ElasticBeam3d::getInitialStiff(void) { // const Vector &v = theCoordTransf->getBasicTrialDisp(); double L = theCoordTransf->getInitialLength(); double oneOverL = 1.0/L; double EoverL = E*oneOverL; double EAoverL = A*EoverL; // EA/L double EIzoverL2 = 2.0*Iz*EoverL; // 2EIz/L double EIzoverL4 = 2.0*EIzoverL2; // 4EIz/L double EIyoverL2 = 2.0*Iy*EoverL; // 2EIy/L double EIyoverL4 = 2.0*EIyoverL2; // 4EIy/L double GJoverL = G*Jx*oneOverL; // GJ/L kb(0,0) = EAoverL; kb(1,1) = kb(2,2) = EIzoverL4; kb(2,1) = kb(1,2) = EIzoverL2; kb(3,3) = kb(4,4) = EIyoverL4; kb(4,3) = kb(3,4) = EIyoverL2; kb(5,5) = GJoverL; return theCoordTransf->getInitialGlobalStiffMatrix(kb); }
int ElastomericBearingBoucWen2d::getResponse(int responseID, Information &eleInfo) { double kGeo1, MpDelta1, MpDelta2, MpDelta3; switch (responseID) { case 1: // global forces return eleInfo.setVector(this->getResistingForce()); case 2: // local forces theVector.Zero(); // determine resisting forces in local system theVector.addMatrixTransposeVector(0.0, Tlb, qb, 1.0); // add P-Delta moments kGeo1 = 0.5*qb(0); MpDelta1 = kGeo1*(ul(4)-ul(1)); theVector(2) += MpDelta1; theVector(5) += MpDelta1; MpDelta2 = kGeo1*shearDistI*L*ul(2); theVector(2) += MpDelta2; theVector(5) -= MpDelta2; MpDelta3 = kGeo1*(1.0 - shearDistI)*L*ul(5); theVector(2) -= MpDelta3; theVector(5) += MpDelta3; return eleInfo.setVector(theVector); case 3: // basic forces return eleInfo.setVector(qb); case 4: // local displacements return eleInfo.setVector(ul); case 5: // basic displacements return eleInfo.setVector(ub); case 6: // hysteretic evolution parameter return eleInfo.setDouble(z); case 7: // dzdu return eleInfo.setDouble(dzdu); case 8: // basic stiffness return eleInfo.setDouble(kb(1,1)); default: return -1; } }
ndt::type resolve(base_callable *DYND_UNUSED(caller), char *DYND_UNUSED(data), call_graph &cg, const ndt::type &dst_tp, size_t nsrc, const ndt::type *src_tp, size_t nkwd, const array *kwds, const std::map<std::string, ndt::type> &tp_vars) { cg.emplace_back([](kernel_builder &kb, kernel_request_t kernreq, char *data, const char *dst_arrmeta, size_t nsrc, const char *const *src_arrmeta) { kb.emplace_back<where_kernel>( kernreq, data, reinterpret_cast<const ndt::var_dim_type::metadata_type *>(dst_arrmeta)->stride, reinterpret_cast<const ndt::var_dim_type::metadata_type *>(dst_arrmeta)->blockref); kb(kernel_request_single, nullptr, nullptr, nsrc - 1, src_arrmeta); }); m_child->resolve(this, nullptr, cg, ndt::make_type<bool>(), nsrc - 1, src_tp, nkwd, kwds, tp_vars); return dst_tp; }
ndt::type resolve(base_callable *DYND_UNUSED(caller), char *DYND_UNUSED(data), call_graph &cg, const ndt::type &dst_tp, size_t nsrc, const ndt::type *src_tp, size_t nkwd, const array *kwds, const std::map<std::string, ndt::type> &tp_vars) { cg.emplace_back([](kernel_builder &kb, kernel_request_t kernreq, char *DYND_UNUSED(data), const char *dst_arrmeta, size_t nsrc, const char *const *src_arrmeta) { kb.emplace_back<right_compound_kernel>(kernreq); const char *child_src_arrmeta[2] = {src_arrmeta[0], dst_arrmeta}; kb(kernreq | kernel_request_data_only, nullptr, dst_arrmeta, nsrc + 1, child_src_arrmeta); }); ndt::type child_src_tp[2] = {src_tp[0], dst_tp}; m_child->resolve(this, nullptr, cg, dst_tp, nsrc + 1, child_src_tp, nkwd, kwds, tp_vars); return dst_tp; }
void subresolve(call_graph &cg, const char *data) { std::array<bool, N> arg_broadcast = reinterpret_cast<const node_type *>(data)->arg_broadcast; std::array<bool, N> arg_var = reinterpret_cast<const node_type *>(data)->arg_var; intptr_t res_alignment = reinterpret_cast<const node_type *>(data)->res_alignment; cg.emplace_back([arg_broadcast, arg_var, res_alignment]( kernel_builder &kb, kernel_request_t kernreq, char *DYND_UNUSED(data), const char *dst_arrmeta, size_t DYND_UNUSED(nsrc), const char *const *src_arrmeta) { const ndt::var_dim_type::metadata_type *dst_md = reinterpret_cast<const ndt::var_dim_type::metadata_type *>(dst_arrmeta); std::array<const char *, N> child_src_arrmeta; std::array<intptr_t, N> src_stride; std::array<intptr_t, N> src_offset; std::array<intptr_t, N> src_size; for (size_t i = 0; i < N; ++i) { if (arg_var[i]) { const ndt::var_dim_type::metadata_type *src_md = reinterpret_cast<const ndt::var_dim_type::metadata_type *>(src_arrmeta[i]); src_stride[i] = src_md->stride; src_offset[i] = src_md->offset; child_src_arrmeta[i] = src_arrmeta[i] + sizeof(ndt::var_dim_type::metadata_type); // src_size[i] = -1; } else { if (arg_broadcast[i]) { src_stride[i] = 0; src_offset[i] = 0; child_src_arrmeta[i] = src_arrmeta[i]; src_size[i] = 1; } else { src_offset[i] = 0; src_stride[i] = reinterpret_cast<const size_stride_t *>(src_arrmeta[i])->stride; src_size[i] = reinterpret_cast<const size_stride_t *>(src_arrmeta[i])->dim_size; } } } kb.emplace_back<elwise_kernel<var_dim_id, fixed_dim_id, TraitsType, N>>( kernreq, dst_md->blockref.get(), res_alignment, dst_md->stride, dst_md->offset, src_stride.data(), src_offset.data(), src_size.data(), arg_var.data()); kb(kernel_request_strided, nullptr, dst_arrmeta + sizeof(ndt::var_dim_type::metadata_type), N, child_src_arrmeta.data()); }); }
bool build(int nthreads=1) { size_t numElem = data_.size(); KeyIterator<decltype(data_.begin())> kb(data_.begin()); KeyIterator<decltype(data_.begin())> ke(data_.end()); auto keyIt = boomphf::range(kb, ke); BooPHFT* ph = new BooPHFT(numElem, keyIt, nthreads); boophf_.reset(ph); std::cerr << "reordering keys and values to coincide with phf ... "; std::vector<size_t> inds; inds.reserve(data_.size()); for (size_t i = 0; i < data_.size(); ++i) { inds.push_back(ph->lookup(data_[i].first)); } reorder_destructive_(inds.begin(), inds.end(), data_.begin()); std::cerr << "done\n"; built_ = true; return built_; }
ndt::type resolve(base_callable *caller, char *data, call_graph &cg, const ndt::type &dst_tp, size_t DYND_UNUSED(nsrc), const ndt::type *src_tp, size_t nkwd, const array *kwds, const std::map<std::string, ndt::type> &tp_vars) { base_callable *child = reinterpret_cast<data_type *>(data)->child; size_t &i = reinterpret_cast<data_type *>(data)->i; cg.emplace_back([i](kernel_builder &kb, kernel_request_t kernreq, char *data, const char *dst_arrmeta, size_t DYND_UNUSED(nsrc), const char *const *src_arrmeta) { kb.emplace_back<outer_kernel<NArg>>(kernreq, i, dst_arrmeta, src_arrmeta); const char *src_element_arrmeta[NArg]; for (size_t j = 0; j < i; ++j) { src_element_arrmeta[j] = src_arrmeta[j]; } src_element_arrmeta[i] = src_arrmeta[i] + sizeof(size_stride_t); for (size_t j = i + 1; j < NArg; ++j) { src_element_arrmeta[j] = src_arrmeta[j]; } kb(kernel_request_strided, data, dst_arrmeta + sizeof(size_stride_t), NArg, src_element_arrmeta); }); ndt::type arg_element_tp[NArg]; for (size_t j = 0; j < i; ++j) { arg_element_tp[j] = src_tp[j]; } arg_element_tp[i] = src_tp[i].extended<ndt::base_dim_type>()->get_element_type(); for (size_t j = i + 1; j < NArg; ++j) { arg_element_tp[j] = src_tp[j]; } size_t j = i; while (i < NArg && arg_element_tp[i].is_scalar()) { ++i; } ndt::type ret_element_tp; if (i < NArg) { ret_element_tp = caller->resolve(this, data, cg, dst_tp, NArg, arg_element_tp, nkwd, kwds, tp_vars); } else { ret_element_tp = child->resolve(this, nullptr, cg, child->get_ret_type(), NArg, arg_element_tp, nkwd, kwds, tp_vars); } return src_tp[j].extended<ndt::base_dim_type>()->with_element_type(ret_element_tp); }
void SAFER::Base::UncheckedSetKey(const byte *userkey_1, unsigned int length, const NameValuePairs ¶ms) { bool strengthened = Strengthened(); unsigned int nof_rounds = params.GetIntValueWithDefault(Name::Rounds(), length == 8 ? (strengthened ? 8 : 6) : 10); const byte *userkey_2 = length == 8 ? userkey_1 : userkey_1 + 8; keySchedule.New(1 + BLOCKSIZE * (1 + 2 * nof_rounds)); unsigned int i, j; byte *key = keySchedule; SecByteBlock ka(BLOCKSIZE + 1), kb(BLOCKSIZE + 1); if (MAX_ROUNDS < nof_rounds) nof_rounds = MAX_ROUNDS; *key++ = (unsigned char)nof_rounds; ka[BLOCKSIZE] = 0; kb[BLOCKSIZE] = 0; for (j = 0; j < BLOCKSIZE; j++) { ka[BLOCKSIZE] ^= ka[j] = rotlFixed(userkey_1[j], 5U); kb[BLOCKSIZE] ^= kb[j] = *key++ = userkey_2[j]; } for (i = 1; i <= nof_rounds; i++) { for (j = 0; j < BLOCKSIZE + 1; j++) { ka[j] = rotlFixed(ka[j], 6U); kb[j] = rotlFixed(kb[j], 6U); } for (j = 0; j < BLOCKSIZE; j++) if (strengthened) *key++ = (ka[(j + 2 * i - 1) % (BLOCKSIZE + 1)] + exp_tab[exp_tab[18 * i + j + 1]]) & 0xFF; else *key++ = (ka[j] + exp_tab[exp_tab[18 * i + j + 1]]) & 0xFF; for (j = 0; j < BLOCKSIZE; j++) if (strengthened) *key++ = (kb[(j + 2 * i) % (BLOCKSIZE + 1)] + exp_tab[exp_tab[18 * i + j + 10]]) & 0xFF; else *key++ = (kb[j] + exp_tab[exp_tab[18 * i + j + 10]]) & 0xFF; } }
void subresolve(call_graph &cg, const char *data) { bool res_broadcast = reinterpret_cast<const data_type *>(data)->res_ignore; const std::array<bool, N> &arg_broadcast = reinterpret_cast<const data_type *>(data)->arg_broadcast; cg.emplace_back([res_broadcast, arg_broadcast](kernel_builder &kb, kernel_request_t kernreq, char *data, const char *dst_arrmeta, size_t DYND_UNUSED(nsrc), const char *const *src_arrmeta) { size_t size; if (res_broadcast) { size = reinterpret_cast<const size_stride_t *>(src_arrmeta[0])->dim_size; } else { size = reinterpret_cast<const size_stride_t *>(dst_arrmeta)->dim_size; } intptr_t dst_stride; const char *child_dst_arrmeta; if (res_broadcast) { dst_stride = 0; child_dst_arrmeta = dst_arrmeta; } else { dst_stride = reinterpret_cast<const size_stride_t *>(dst_arrmeta)->stride; child_dst_arrmeta = dst_arrmeta + sizeof(size_stride_t); } std::array<intptr_t, N> src_stride; std::array<const char *, N> child_src_arrmeta; for (size_t i = 0; i < N; ++i) { if (arg_broadcast[i]) { src_stride[i] = 0; child_src_arrmeta[i] = src_arrmeta[i]; } else { src_stride[i] = reinterpret_cast<const size_stride_t *>(src_arrmeta[i])->stride; child_src_arrmeta[i] = src_arrmeta[i] + sizeof(size_stride_t); } } kb.emplace_back<elwise_kernel<fixed_dim_id, fixed_dim_id, TraitsType, N>>(kernreq, data, size, dst_stride, src_stride.data()); kb(kernel_request_strided, TraitsType::child_data(data), child_dst_arrmeta, N, child_src_arrmeta.data()); }); }
ndt::type resolve(base_callable *DYND_UNUSED(caller), char *DYND_UNUSED(data), call_graph &cg, const ndt::type &dst_tp, size_t DYND_UNUSED(nsrc), const ndt::type *src_tp, size_t DYND_UNUSED(nkwd), const array *DYND_UNUSED(kwds), const std::map<std::string, ndt::type> &tp_vars) { const ndt::type &src0_element_tp = src_tp[0].extended<ndt::fixed_dim_type>()->get_element_type(); size_t src0_element_data_size = src0_element_tp.get_data_size(); cg.emplace_back([src0_element_data_size](kernel_builder &kb, kernel_request_t kernreq, char *DYND_UNUSED(data), const char *DYND_UNUSED(dst_arrmeta), size_t DYND_UNUSED(nsrc), const char *const *src_arrmeta) { kb.emplace_back<sort_kernel>( kernreq, reinterpret_cast<const fixed_dim_type_arrmeta *>(src_arrmeta[0])->dim_size, reinterpret_cast<const fixed_dim_type_arrmeta *>(src_arrmeta[0])->stride, src0_element_data_size); kb(kernel_request_single, nullptr, nullptr, 2, nullptr); }); const ndt::type child_src_tp[2] = {src0_element_tp, src0_element_tp}; less->resolve(this, nullptr, cg, ndt::make_type<bool1>(), 2, child_src_tp, 0, nullptr, tp_vars); return dst_tp; }
///======================================================================== CDIKeyboard *CDIKeyboard::createKeyboardDevice(IDirectInput8 *di8, HWND hwnd, CDIEventEmitter *diEventEmitter, CWinEventEmitter *we ) throw(EDirectInput) { std::auto_ptr<CDIKeyboard> kb(new CDIKeyboard(we, hwnd)); kb->_DIEventEmitter = diEventEmitter; HRESULT result = di8->CreateDevice(GUID_SysKeyboard, &kb->_Keyboard, NULL); if (result != DI_OK) throw EDirectInputNoKeyboard(); result = kb->_Keyboard->SetCooperativeLevel(hwnd, DISCL_FOREGROUND | DISCL_EXCLUSIVE); if (result != DI_OK) throw EDirectInputCooperativeLevelFailed(); result = kb->_Keyboard->SetDataFormat(&c_dfDIKeyboard); kb->setBufferSize(16); kb->_Keyboard->Acquire(); // Enable win32 keyboard messages only if hardware mouse in normal mode if (kb->_WE) kb->_WE->enableKeyboardEvents(false); return kb.release(); }
SAFER::SAFER(const byte *userkey_1, const byte *userkey_2, unsigned nof_rounds, bool strengthened) : keySchedule(1 + BLOCKSIZE * (1 + 2 * nof_rounds)) { unsigned int i, j; byte *key = keySchedule; SecByteBlock ka(BLOCKSIZE + 1), kb(BLOCKSIZE + 1); if (MAX_ROUNDS < nof_rounds) nof_rounds = MAX_ROUNDS; *key++ = (unsigned char)nof_rounds; ka[BLOCKSIZE] = 0; kb[BLOCKSIZE] = 0; for (j = 0; j < BLOCKSIZE; j++) { ka[BLOCKSIZE] ^= ka[j] = rotlFixed(userkey_1[j], 5U); kb[BLOCKSIZE] ^= kb[j] = *key++ = userkey_2[j]; } for (i = 1; i <= nof_rounds; i++) { for (j = 0; j < BLOCKSIZE + 1; j++) { ka[j] = rotlFixed(ka[j], 6U); kb[j] = rotlFixed(kb[j], 6U); } for (j = 0; j < BLOCKSIZE; j++) if (strengthened) *key++ = (ka[(j + 2 * i - 1) % (BLOCKSIZE + 1)] + exp_tab[exp_tab[18 * i + j + 1]]) & 0xFF; else *key++ = (ka[j] + exp_tab[exp_tab[18 * i + j + 1]]) & 0xFF; for (j = 0; j < BLOCKSIZE; j++) if (strengthened) *key++ = (kb[(j + 2 * i) % (BLOCKSIZE + 1)] + exp_tab[exp_tab[18 * i + j + 10]]) & 0xFF; else *key++ = (kb[j] + exp_tab[exp_tab[18 * i + j + 10]]) & 0xFF; } }