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;
}
}
