/* forward octave */ static inline void W(u32 *key, unsigned int i) { u32 I; key[6] ^= F1(key[7], Tr[i % 4][0], Tm[i][0]); key[5] ^= F2(key[6], Tr[i % 4][1], Tm[i][1]); key[4] ^= F3(key[5], Tr[i % 4][2], Tm[i][2]); key[3] ^= F1(key[4], Tr[i % 4][3], Tm[i][3]); key[2] ^= F2(key[3], Tr[i % 4][4], Tm[i][4]); key[1] ^= F3(key[2], Tr[i % 4][5], Tm[i][5]); key[0] ^= F1(key[1], Tr[i % 4][6], Tm[i][6]); key[7] ^= F2(key[0], Tr[i % 4][7], Tm[i][7]); }
static void cast5_encrypt(struct crypto_tfm *tfm, u8 *outbuf, const u8 *inbuf) { struct cast5_ctx *c = crypto_tfm_ctx(tfm); const __be32 *src = (const __be32 *)inbuf; __be32 *dst = (__be32 *)outbuf; u32 l, r, t; u32 I; /* used by the Fx macros */ u32 *Km; u8 *Kr; Km = c->Km; Kr = c->Kr; /* (L0,R0) <-- (m1...m64). (Split the plaintext into left and * right 32-bit halves L0 = m1...m32 and R0 = m33...m64.) */ l = be32_to_cpu(src[0]); r = be32_to_cpu(src[1]); /* (16 rounds) for i from 1 to 16, compute Li and Ri as follows: * Li = Ri-1; * Ri = Li-1 ^ f(Ri-1,Kmi,Kri), where f is defined in Section 2.2 * Rounds 1, 4, 7, 10, 13, and 16 use f function Type 1. * Rounds 2, 5, 8, 11, and 14 use f function Type 2. * Rounds 3, 6, 9, 12, and 15 use f function Type 3. */ t = l; l = r; r = t ^ F1(r, Km[0], Kr[0]); t = l; l = r; r = t ^ F2(r, Km[1], Kr[1]); t = l; l = r; r = t ^ F3(r, Km[2], Kr[2]); t = l; l = r; r = t ^ F1(r, Km[3], Kr[3]); t = l; l = r; r = t ^ F2(r, Km[4], Kr[4]); t = l; l = r; r = t ^ F3(r, Km[5], Kr[5]); t = l; l = r; r = t ^ F1(r, Km[6], Kr[6]); t = l; l = r; r = t ^ F2(r, Km[7], Kr[7]); t = l; l = r; r = t ^ F3(r, Km[8], Kr[8]); t = l; l = r; r = t ^ F1(r, Km[9], Kr[9]); t = l; l = r; r = t ^ F2(r, Km[10], Kr[10]); t = l; l = r; r = t ^ F3(r, Km[11], Kr[11]); if (!(c->rr)) { t = l; l = r; r = t ^ F1(r, Km[12], Kr[12]); t = l; l = r; r = t ^ F2(r, Km[13], Kr[13]); t = l; l = r; r = t ^ F3(r, Km[14], Kr[14]); t = l; l = r; r = t ^ F1(r, Km[15], Kr[15]); } /* c1...c64 <-- (R16,L16). (Exchange final blocks L16, R16 and * concatenate to form the ciphertext.) */ dst[0] = cpu_to_be32(r); dst[1] = cpu_to_be32(l); }
void ChannelSelector::setCubiePower(bool mode) { if (mode == false) { digitalWrite(PIN_CUBIEPOWER, LOW); GLOBALS.cubie_power_enabled = false; MDISPLAY.showMessage(F2("Power Off")); } else { digitalWrite(PIN_CUBIEPOWER, HIGH); GLOBALS.cubie_power_enabled = true; MDISPLAY.showMessage(F2("Power On")); } }
void q_promote( q_expr e) { q_expr leftTerm, rightTerm; q_expr newTerm; assert(e != NULL); assert(e->kind == T_FNC); assert(e->info.function->tag == Q_EXPR_AND); leftTerm = q_leftPar(e); rightTerm = q_rightPar(e); q_disjunctify(leftTerm); q_disjunctify(rightTerm); if (q_isFnc(leftTerm,Q_EXPR_OR)) { /* e = (A or B) and C ====> e = A and C or B and C */ newTerm = F2(Q_EXPR_AND,q_rightPar(leftTerm),q_exprCopy(rightTerm)); /* e = (A or B) and C; newTerm = B and C */ q_promote(newTerm); q_swapRight(leftTerm,q_swapRight(e,newTerm)); /* e = (A or C) and (B and C); */ q_setTag(leftTerm,Q_EXPR_AND); /* e = (A and C) and (B and C); */ q_promote(leftTerm); q_setTag(e,Q_EXPR_OR); /* e = (A and C) or (B and C); */ if (q_isFnc(rightTerm,Q_EXPR_OR)) { /* e = (A and (C or D)) or (B and (C or D)); */ q_promote(leftTerm); /* e = (A and C) or (A and D)) or (B and (C or D)); */ q_promote(newTerm); /* e = ((A and C) or (A and D)) or ((B and C) or (A and D)); */ } } else { if (q_isFnc(rightTerm,Q_EXPR_OR)) { /* e = A and (B or C) ====> e = A and B or A and C */ newTerm = F2(Q_EXPR_AND,q_exprCopy(leftTerm),q_leftPar(rightTerm)); /* e = A and (B or C); newTerm = A and B */ q_swapLeft(rightTerm,q_swapLeft(e,newTerm)); /* e = (A and B) and (A or C); */ q_setTag(rightTerm,Q_EXPR_AND); /* e = (A and B) and (A and C); */ q_setTag(e,Q_EXPR_OR); /* e = (A and B) or (A and C); */ } } }
void rubikStep(char *step) { u8 m=0; for(m=0;step[m]!=0;m++) { switch(step[m]) { case 7:allright90();break; case 11:F1();break; case 12:F2();break; case 13:F3();break; case 21:B1();break; case 22:B2();break; case 23:B3();break; case 31:R1();break; case 32:R2();break; case 33:R3();break; case 41:L1();break; case 42:L2();break; case 43:L3();break; case 51:U1();break; case 52:U2();break; case 53:U3();break; case 61:D1();break; case 62:D2();break; case 63:D3();break; default:break; } } }
void vsip_vinterp_nearest_f( const vsip_vview_f *x0, const vsip_vview_f *y0, const vsip_vview_f *x, const vsip_vview_f *y){ vsip_length N0 = x0->length; vsip_length N = x->length; vsip_stride x0_str = x0->stride * x0->block->rstride, y0_str = y0->stride * y0->block->rstride, x_str = x->stride * x->block->rstride, y_str = y->stride * y->block->rstride; vsip_scalar_f *x0_ptr = x0->block->array + x0->offset * x0->block->rstride, *y0_ptr = y0->block->array + y0->offset * y0->block->rstride, *x_ptr = x->block->array + x->offset * x->block->rstride, *y_ptr = y->block->array + y->offset * y->block->rstride; vsip_index i=0,j=0; vsip_scalar_f sx1,sx2,sy1,sy2,sx; while((j < N) && (i < N0-1)){ sx1 = x0_ptr[i * x0_str]; sx2 = x0_ptr[(i+1)*x0_str]; sy1 = y0_ptr[i * y0_str]; sy2 = y0_ptr[(i+1) * y0_str]; sx = x_ptr[j * x_str]; if(sx < sx2) { vsip_scalar_f a; F2(sx1,sx2,sy1,sy2,sx,a); y_ptr[j * y_str] = a; j++; } else i++; } return; }
/*reverse quad round*/ static inline void QBAR (u32 * block, u8 * Kr, u32 * Km) { u32 I; block[3] ^= F1(block[0], Kr[3], Km[3]); block[0] ^= F3(block[1], Kr[2], Km[2]); block[1] ^= F2(block[2], Kr[1], Km[1]); block[2] ^= F1(block[3], Kr[0], Km[0]); }
TEST(RecorderTest, ArgRecorderTest) { TRACER_TRACE(&F2) f2; auto f2a = tracer::RecordArgs(f2); int a = 5; F2(a); for (int i = a; i >= 0; i--) EXPECT_EQ(5 - i, f2a.Arg<0>(i)); }
static void cast5_decrypt(void *ctx, u8 * outbuf, const u8 * inbuf) { struct cast5_ctx *c = (struct cast5_ctx *) ctx; const __be32 *src = (const __be32 *)inbuf; __be32 *dst = (__be32 *)outbuf; u32 l, r, t; u32 I; u32 *Km; u8 *Kr; Km = c->Km; Kr = c->Kr; l = be32_to_cpu(src[0]); r = be32_to_cpu(src[1]); if (!(c->rr)) { t = l; l = r; r = t ^ F1(r, Km[15], Kr[15]); t = l; l = r; r = t ^ F3(r, Km[14], Kr[14]); t = l; l = r; r = t ^ F2(r, Km[13], Kr[13]); t = l; l = r; r = t ^ F1(r, Km[12], Kr[12]); t = l; l = r; r = t ^ F3(r, Km[11], Kr[11]); t = l; l = r; r = t ^ F2(r, Km[10], Kr[10]); t = l; l = r; r = t ^ F1(r, Km[9], Kr[9]); t = l; l = r; r = t ^ F3(r, Km[8], Kr[8]); t = l; l = r; r = t ^ F2(r, Km[7], Kr[7]); t = l; l = r; r = t ^ F1(r, Km[6], Kr[6]); t = l; l = r; r = t ^ F3(r, Km[5], Kr[5]); t = l; l = r; r = t ^ F2(r, Km[4], Kr[4]); t = l; l = r; r = t ^ F1(r, Km[3], Kr[3]); t = l; l = r; r = t ^ F3(r, Km[2], Kr[2]); t = l; l = r; r = t ^ F2(r, Km[1], Kr[1]); t = l; l = r; r = t ^ F1(r, Km[0], Kr[0]); } else { t = l; l = r; r = t ^ F3(r, Km[11], Kr[11]); t = l; l = r; r = t ^ F2(r, Km[10], Kr[10]); t = l; l = r; r = t ^ F1(r, Km[9], Kr[9]); t = l; l = r; r = t ^ F3(r, Km[8], Kr[8]); t = l; l = r; r = t ^ F2(r, Km[7], Kr[7]); t = l; l = r; r = t ^ F1(r, Km[6], Kr[6]); t = l; l = r; r = t ^ F3(r, Km[5], Kr[5]); t = l; l = r; r = t ^ F2(r, Km[4], Kr[4]); t = l; l = r; r = t ^ F1(r, Km[3], Kr[3]); t = l; l = r; r = t ^ F3(r, Km[2], Kr[2]); t = l; l = r; r = t ^ F2(r, Km[1], Kr[1]); t = l; l = r; r = t ^ F1(r, Km[0], Kr[0]); } dst[0] = cpu_to_be32(r); dst[1] = cpu_to_be32(l); }
const char* ChannelSelector::getChannelName() { if (current_channel>CHANNEL_NONE && current_channel<CHANNEL_LAST) { return (const char*)channel_names[(int)current_channel]; } else { return (const char*)F2("N/A"); } }
void ChannelSelector::setActiveChannel(CHANNEL channel) { CHANNEL new_channel = channel; if (channel<AUX) new_channel = BLUETOOTH; if (channel>BLUETOOTH) new_channel = AUX; //Serial.print(F("setActiveChannel=>")); //Serial.println(new_channel); if (current_channel != new_channel) { digitalWrite(channel_pins[(int)new_channel], HIGH); delay(10); digitalWrite(channel_pins[(int)current_channel], LOW); if (new_channel == BLUETOOTH) { if (GLOBALS.bluetooth_power_enabled == false) { //sendCommand(CMD_BT_POWER); MDISPLAY.showMessage(F2("Processing ...")); EXPANDER.bluetoothPress(BT_POWER); MDISPLAY.showMessage(F2("BT Enabled ...")); } } current_channel = new_channel; CONFIG.values().stored_channel = current_channel; MDISPLAY.updateScreen(); CONFIG.store(); } }
int main() { auto a1 = F1(); auto a2 = F2(); auto a3 = F3(); auto a4 = F4(); auto a5 = F5(); return 0; }
void cast_decrypt(cast_key* key, u_int8_t* inblock, u_int8_t* outblock) { u_int32_t t, l, r; /* Get inblock into l,r */ r = ((u_int32_t)inblock[0] << 24) | ((u_int32_t)inblock[1] << 16) | ((u_int32_t)inblock[2] << 8) | (u_int32_t)inblock[3]; l = ((u_int32_t)inblock[4] << 24) | ((u_int32_t)inblock[5] << 16) | ((u_int32_t)inblock[6] << 8) | (u_int32_t)inblock[7]; /* Do the work */ /* Only do full 16 rounds if key length > 80 bits */ if (key->rounds > 12) { F1(r, l, 15); F3(l, r, 14); F2(r, l, 13); F1(l, r, 12); } F3(r, l, 11); F2(l, r, 10); F1(r, l, 9); F3(l, r, 8); F2(r, l, 7); F1(l, r, 6); F3(r, l, 5); F2(l, r, 4); F1(r, l, 3); F3(l, r, 2); F2(r, l, 1); F1(l, r, 0); /* Put l,r into outblock */ outblock[0] = U8a(l); outblock[1] = U8b(l); outblock[2] = U8c(l); outblock[3] = U8d(l); outblock[4] = U8a(r); outblock[5] = U8b(r); outblock[6] = U8c(r); outblock[7] = U8d(r); /* Wipe clean */ t = l = r = 0; }
static q_expr q_deNot( q_expr e) { q_expr r; if (e == NULL) { return NULL; } if (e->kind == T_FNC) { switch (e->info.function->tag) { case Q_EXPR_LIKE: r = e; break; case Q_EXPR_EQ: e->info.function->tag = Q_EXPR_NE; r = e; break; case Q_EXPR_NE: e->info.function->tag = Q_EXPR_EQ; r = e; break; case Q_EXPR_LT: e->info.function->tag = Q_EXPR_GE; r = e; break; case Q_EXPR_LE: e->info.function->tag = Q_EXPR_GT; r = e; break; case Q_EXPR_GT: e->info.function->tag = Q_EXPR_LE; r = e; break; case Q_EXPR_GE: e->info.function->tag = Q_EXPR_LT; r = e; break; case Q_EXPR_NOT: r = q_takePar(e,0); q_dispose(e); break; case Q_EXPR_AND: r = F2(Q_EXPR_OR,q_removeNots(q_takePar(e,0)),q_removeNots(q_takePar(e,1))); q_dispose(e); break; case Q_EXPR_OR: r = F2(Q_EXPR_AND,q_removeNots(q_takePar(e,0)),q_removeNots(q_takePar(e,1))); q_dispose(e); break; default: assert(FALSE); r = e; break; } } else { r = e; } return r; }
void CAST5decrypt(const PGPUInt8 *in, PGPUInt8 *out, const PGPUInt32 *xkey) { PGPUInt32 l, r, t; r = (PGPUInt32) in[0]<<24 | (PGPUInt32) in[1]<<16 | (PGPUInt32) in[2]<<8 | in[3]; l = (PGPUInt32) in[4]<<24 | (PGPUInt32) in[5]<<16 | (PGPUInt32) in[6]<<8 | in[7]; t = F1(l, xkey, 15); r ^= G1(t); t = F3(r, xkey, 14); l ^= G3(t); t = F2(l, xkey, 13); r ^= G2(t); t = F1(r, xkey, 12); l ^= G1(t); // Start here if only doing 12 rounds t = F3(l, xkey, 11); r ^= G3(t); t = F2(r, xkey, 10); l ^= G2(t); t = F1(l, xkey, 9); r ^= G1(t); t = F3(r, xkey, 8); l ^= G3(t); t = F2(l, xkey, 7); r ^= G2(t); t = F1(r, xkey, 6); l ^= G1(t); t = F3(l, xkey, 5); r ^= G3(t); t = F2(r, xkey, 4); l ^= G2(t); t = F1(l, xkey, 3); r ^= G1(t); t = F3(r, xkey, 2); l ^= G3(t); t = F2(l, xkey, 1); r ^= G2(t); t = F1(r, xkey, 0); l ^= G1(t); out[0] = (PGPUInt8) B0(l); out[1] = (PGPUInt8) B1(l); out[2] = (PGPUInt8) B2(l); out[3] = (PGPUInt8) B3(l); out[4] = (PGPUInt8) B0(r); out[5] = (PGPUInt8) B1(r); out[6] = (PGPUInt8) B2(r); out[7] = (PGPUInt8) B3(r); }
static void bf_e_block(uint32_t *p_xl, uint32_t *p_xr) { uint32_t temp; uint32_t xl = *p_xl; uint32_t xr = *p_xr; F1(0) F2(1) F1(2) F2(3) F1(4) F2(5) F1(6) F2(7) F1(8) F2(9) F1(10) F2(11) F1(12) F2(13) F1(14) F2(15) xl ^= pax[16]; xr ^= pax[17]; temp = xl; xl = xr; xr = temp; *p_xl = xl; *p_xr = xr; }
void Vector_Drive(vector V, double omega) { vector F1(-1.000,0.000), F2(0.500,-0.866), F3(0.866,0.500); double omega1, omega2, omega3, b=0.090, r=0.020, h=0; omega1 = ( F1*V + b*omega ) / r; // F1*V is overloaded dot product omega2 = ( F2*V + b*omega ) / r; omega3 = ( F3*V + b*omega ) / r; // makes sure that given path is physically possible if ( (omega1>6) || (omega2>6) || (omega3>6) || (omega1<-6) || (omega2<-6) || (omega3<-6) ) DisplayTxt("Vectors: ERROR!"); else Drive(Vel_To_Value(omega1),Vel_To_Value(omega2),Vel_To_Value(omega3)); }
/* * Encrypt the 8 bytes at *in into the 8 bytes at *out using the expanded * key schedule from *xkey. */ static void CAST5encrypt(PGPByte const *in, PGPByte *out, PGPUInt32 const *xkey) { PGPUInt32 l, r, t; l = (PGPUInt32) in[0]<<24 | (PGPUInt32)in[1]<<16 | (PGPUInt32)in[2]<<8 | in[3]; r = (PGPUInt32) in[4]<<24 | (PGPUInt32)in[5]<<16 | (PGPUInt32)in[6]<<8 | in[7]; t = F1(r, xkey, 0); l ^= G1(t); t = F2(l, xkey, 1); r ^= G2(t); t = F3(r, xkey, 2); l ^= G3(t); t = F1(l, xkey, 3); r ^= G1(t); t = F2(r, xkey, 4); l ^= G2(t); t = F3(l, xkey, 5); r ^= G3(t); t = F1(r, xkey, 6); l ^= G1(t); t = F2(l, xkey, 7); r ^= G2(t); t = F3(r, xkey, 8); l ^= G3(t); t = F1(l, xkey, 9); r ^= G1(t); t = F2(r, xkey, 10); l ^= G2(t); t = F3(l, xkey, 11); r ^= G3(t); /* Stop here if only doing 12 rounds */ t = F1(r, xkey, 12); l ^= G1(t); t = F2(l, xkey, 13); r ^= G2(t); t = F3(r, xkey, 14); l ^= G3(t); t = F1(l, xkey, 15); r ^= G1(t); out[0] = B0(r); out[1] = B1(r); out[2] = B2(r); out[3] = B3(r); out[4] = B0(l); out[5] = B1(l); out[6] = B2(l); out[7] = B3(l); }
seconlevel_f4::seconlevel_f4(QWidget *parent) : QWidget(parent), ui(new Ui::seconlevel_f4) { ui->setupUi(this); group = new GroupDialog(parent); group->hide(); connect(group ,SIGNAL(finished(int)) ,this ,SLOT(f1_Done(int))); autotab = new AutoDialog(parent); autotab->hide(); connect(autotab ,SIGNAL(finished(int)) ,this ,SLOT(f2_Done(int))); jump = new JumpDialog(parent); jump->hide(); connect(jump ,SIGNAL(finished(int)) ,this ,SLOT(f6_Done(int))); connect(ui->pushButton_F1,SIGNAL(clicked()),this ,SLOT(F1())); ui->pushButton_F1->setCheckable(true); connect(ui->pushButton_F2,SIGNAL(clicked()),this ,SLOT(F2())); ui->pushButton_F2->setCheckable(true); connect(ui->pushButton_F3,SIGNAL(clicked()),this ,SLOT(F3())); ui->pushButton_F3->setCheckable(true); connect(ui->pushButton_F4,SIGNAL(clicked()),this ,SLOT(F4())); ui->pushButton_F4->setCheckable(true); connect(ui->pushButton_F5,SIGNAL(clicked()),this ,SLOT(F5())); ui->pushButton_F5->setCheckable(true); connect(ui->pushButton_F6,SIGNAL(clicked()),this ,SLOT(F6())); ui->pushButton_F6->setCheckable(true); connect(ui->pushButton_F7,SIGNAL(clicked()),this ,SLOT(F7())); ui->pushButton_F7->setCheckable(true); connect(this ,SIGNAL(enter(int)),parent ,SLOT(funcbarUpdate(int))); connect(ui->pushButton_F8,SIGNAL(clicked()),this ,SLOT(F8())); /*数据表模式改变信号*/ connect(this ,SIGNAL(stateChange(char)) ,parent ,SLOT(tableStateUpdate(char))); /*段选信号*/ connect(this ,SIGNAL(selectRows(bool)) ,parent ,SLOT(tableSelect(bool))); setFocusPolicy(Qt::NoFocus); }
int main() { typedef OKlib::Literals::Literals_int literal_type; typedef std::vector<literal_type> clause_type; typedef std::vector<clause_type> clause_set1_type; typedef OKlib::InputOutput::RawDimacsCLSAdaptor<literal_type, clause_set1_type> InputClsadaptor; InputClsadaptor F1; OKlib::InputOutput::StandardDIMACSInput<InputClsadaptor>(std::cin, F1); const InputClsadaptor::int_type n = F1.stat.parameter_n; typedef std::list<clause_type> clause_set2_type; clause_set2_type F2(F1.clause_set.begin(), F1.clause_set.end()); F1.clause_set.clear(); if (F2.size() >= 2) { clause_set2_type F_removed; typedef clause_set2_type::iterator clause_iterator; const clause_iterator F2end = F2.end(); for (struct {clause_iterator Ci, next;} l = {F2.begin(), boost::next(F2.begin())}; l.Ci != F2end; l.Ci = l.next) { l.next = boost::next(l.Ci); F_removed.splice(F_removed.begin(), F2, l.Ci); typedef OKlib::Satisfiability::Reductions::UnitClausePropagation::CLSAdaptorUcpW< OKlib::Satisfiability::ProblemInstances::Clauses::WatchedLiterals_mono<literal_type>, OKlib::Satisfiability::Assignments::TotalAssignments::BAssignmentWithQueue<literal_type> > Ucp; Ucp U; OKlib::InputOutput::ListTransfer<Ucp>(F2, U, n); const Ucp::assignment_type f(U.assignment()); if (U.contradicting_uclause()) continue; bool removable = true; const clause_iterator Frend = F_removed.end(); for (clause_iterator Di = F_removed.begin(); Di != Frend; ++Di, U.contradicting_uclause() = false) { U.set_assignments(f); const clause_type& D = *Di; typedef clause_type::const_iterator literal_iterator; for (literal_iterator xi = D.begin(); xi != D.end(); ++xi) U.push_unit_clause(-*xi); if (not U.perform_ucp()) { removable = false; break; } } if (not removable) F2.splice(l.next, F_removed, F_removed.begin()); } } { typedef OKlib::InputOutput::CLSAdaptorDIMACSOutput<literal_type> OutputClsadaptor; OutputClsadaptor out(std::cout); OKlib::InputOutput::ListTransfer<OutputClsadaptor>(F2, out, ""); } }
int g(unsigned char *in,int i,dword *h) { dword h0,h1,h2,h3,h4,a,b,c,d,e,temp; unsigned char *kp; dword w[80]; kp = in; h0 = WORD(kp); kp += 4; h1 = WORD(kp); kp += 4; h2 = WORD(kp); kp += 4; h3 = WORD(kp); kp += 4; h4 = WORD(kp); kp += 4; w[0] = i; for (i=1;i<16;i++) w[i] = 0; for (i=16;i<80;i++) w[i] = w[i-3]^w[i-8]^w[i-14]^w[i-16]; a = h0; b = h1; c = h2; d = h3; e = h4; for(i=0;i<20;i++) { temp = ROT27(a) + F1(b, c, d) + e + w[i] + 0x5a827998; e = d; d = c; c = ROT2(b); b = a; a = temp; } for (i=20;i<40;i++) { temp = ROT27(a) + F2(b, c, d) + e + w[i] + 0x6ef9eba1; e = d; d = c; c = ROT2(b); b = a; a = temp; } for (i=40;i<60;i++) { temp = ROT27(a) + F3(b, c, d) + e + w[i] + 0x7f1cbcdc; e = d; d = c; c = ROT2(b); b = a; a = temp; } for (i=60;i<80;i++) { temp = ROT27(a) + F4(b, c, d) + e + w[i] + 0xaa62d1d6; e = d; d = c; c = ROT2(b); b = a; a = temp; } h[0] = h0+a; h[1] = h1+b; h[2] = h2+c; h[3] = h3+d; h[4] = h4+e; return (ALG_OK); }
void sha256_transform (uint32 *buf, uint32 const *in) { uint32 w[64] ; unsigned int i = 0 ; register uint32 a = buf[0], b = buf[1], c = buf[2], d = buf[3], e = buf[4], f = buf[5], g = buf[6], h = buf[7] ; for (; i < 16 ; i++) w[i] = in[i] ; for (; i < 64 ; i++) w[i] = SMALLSIGMA1(w[i-2]) + w[i-7] + SMALLSIGMA0(w[i-15]) + w[i-16] ; for (i = 0 ; i < 64 ; i++) { uint32 temp1 = h + CAPITALSIGMA1(e) + F1(e, f, g) + sha256_constants[i] + w[i] ; uint32 temp2 = CAPITALSIGMA0(a) + F2(a, b, c) ; h = g ; g = f ; f = e ; e = d + temp1 ; d = c ; c = b ; b = a ; a = temp1 + temp2 ; } buf[0] += a ; buf[1] += b ; buf[2] += c ; buf[3] += d ; buf[4] += e ; buf[5] += f ; buf[6] += g ; buf[7] += h ; }
void ChannelSelector::setAmpPower(bool mode) { MDISPLAY.showMessage(F2("Processing ...")); uint8_t cmd = 0; if (mode) { // power on amp cmd = (uint8_t)(CMD_PWR_AMP_ON); Wire.beginTransmission(ADDR_PWR); Wire.write(cmd); Wire.endTransmission(true); delay(2000); // set mute off cmd = (uint8_t)(CMD_VOL_MUTE_OFF); Wire.beginTransmission(ADDR_VOLUME); Wire.write(cmd); Wire.endTransmission(true); delay(1000); } else { // set mute on cmd = (uint8_t)(CMD_VOL_MUTE_ON); Wire.beginTransmission(ADDR_VOLUME); Wire.write(cmd); Wire.endTransmission(true); delay(1000); // power off amp cmd = (uint8_t)(CMD_PWR_AMP_OFF); Wire.beginTransmission(ADDR_PWR); Wire.write(cmd); Wire.endTransmission(true); delay(2000); } GLOBALS.amp_power_enabled = mode; }
int main() { std_setup(); ml_random rng; { // output analytic solution grid2D<double, double > F1( 500, -10.0, 10.0, 500, -10.0, 10.0 ); grid2D<double, double > F2( F1 ); grid2D<double, double > G1( F1 ); grid2D<double, double > G2( F1 ); F1 = V_1; F2 = V_2; laplacian_2d_hdaf Del2; Del2.init( F1.n1, F1.n2, F1.b1-F1.a1, F1.b2-F1.a2, 24, 24, .5, .5 ); Del2.execute( F1.array, G1.array ); Del2.execute( F2.array, G2.array ); plotGrid2D_1( F1, "/workspace/output/scratch/F1.png", color_map_green ); plotGrid2D_1( F2, "/workspace/output/scratch/F2.png", color_map_green ); plotGrid2D_1( G1, "/workspace/output/scratch/G1.png", color_map_error ); plotGrid2D_1( G2, "/workspace/output/scratch/G2.png", color_map_error ); } std_exit(); }
int main() { int t,i,j,k; int x[M][M], y[M][M]; int x3[M][M][M]; for (i = 1 ; i<=M; i++) { for (j = 1; j<=M; j++) { for (k = 1; k<=3; k++) { src(&(x3[i][j][k])); } } } for (i = 1 ; i<=M; i++) { for (j = 1; j<=M; j++) { for (k = 1; k<=3; k++) { if (k <= 2) { F1(&(x3[i][j][k]), &(x3[i][j][k])); } else { F2(&(x3[i][j][k]), &(x3[i][j][k])); } } } } for (i = 1 ; i<=M; i++) { for (j = 1; j<=M; j++) { for (k = 1; k<=3; k++) { sink(&(x3[i][j][k])); } } } return 0; }
Eigen::MatrixXd TimeIntegrator::GeneralisedAlpha(Eigen::MatrixXd &K, Eigen::MatrixXd &M, double &del, double &gam, double &alphaf, double &alpham) { Eigen::MatrixXd U,V,A; U.setZero(K.rows(),_nstep+1); V.setZero(K.rows(),_nstep+1); A.setZero(K.rows(),_nstep+1); Eigen::VectorXd F = Eigen::VectorXd::Zero(K.rows()); Eigen::VectorXd F2 = Eigen::VectorXd::Zero(K.rows()); // Loop over time steps for (int istep=0; istep<_nstep; ++istep) { if (istep==_nstep-1) break; for (int i=0; i<_napp.rows(); ++i) { F(_napp(i)) = F1(istep); F2(_napp(i)) = F1(istep+1); } U.col(istep+1) = ((1-alpham)/_dt/_dt/gam*M+(1-alphaf)*K).llt().solve((1-alphaf)*F2+alphaf*F+((1-alpham)/_dt/_dt/gam*M-alphaf*K)*U.col(istep)+(1-alpham)/_dt/gam*M*V.col(istep)+((1-alpham)*(1.0/2.0/gam-1)-alpham)*M*A.col(istep)); A.col(istep+1) = 1.0/(_dt*_dt*gam)*(U.col(istep+1)-U.col(istep))-1.0/(_dt*gam)*V.col(istep)+(1-1.0/(2.0*gam))*A.col(istep); V.col(istep+1) = V.col(istep)+_dt*(del*A.col(istep+1)+(1-del)*A.col(istep)); } return U; }
static void sha1_step(struct sha1_ctxt *ctxt) { uint32_t a, b, c, d, e; size_t t, s; uint32_t tmp; #if !WORDS_BIGENDIAN struct sha1_ctxt tctxt; memmove(&tctxt.m.b8[0], &ctxt->m.b8[0], 64); ctxt->m.b8[0] = tctxt.m.b8[3]; ctxt->m.b8[1] = tctxt.m.b8[2]; ctxt->m.b8[2] = tctxt.m.b8[1]; ctxt->m.b8[3] = tctxt.m.b8[0]; ctxt->m.b8[4] = tctxt.m.b8[7]; ctxt->m.b8[5] = tctxt.m.b8[6]; ctxt->m.b8[6] = tctxt.m.b8[5]; ctxt->m.b8[7] = tctxt.m.b8[4]; ctxt->m.b8[8] = tctxt.m.b8[11]; ctxt->m.b8[9] = tctxt.m.b8[10]; ctxt->m.b8[10] = tctxt.m.b8[9]; ctxt->m.b8[11] = tctxt.m.b8[8]; ctxt->m.b8[12] = tctxt.m.b8[15]; ctxt->m.b8[13] = tctxt.m.b8[14]; ctxt->m.b8[14] = tctxt.m.b8[13]; ctxt->m.b8[15] = tctxt.m.b8[12]; ctxt->m.b8[16] = tctxt.m.b8[19]; ctxt->m.b8[17] = tctxt.m.b8[18]; ctxt->m.b8[18] = tctxt.m.b8[17]; ctxt->m.b8[19] = tctxt.m.b8[16]; ctxt->m.b8[20] = tctxt.m.b8[23]; ctxt->m.b8[21] = tctxt.m.b8[22]; ctxt->m.b8[22] = tctxt.m.b8[21]; ctxt->m.b8[23] = tctxt.m.b8[20]; ctxt->m.b8[24] = tctxt.m.b8[27]; ctxt->m.b8[25] = tctxt.m.b8[26]; ctxt->m.b8[26] = tctxt.m.b8[25]; ctxt->m.b8[27] = tctxt.m.b8[24]; ctxt->m.b8[28] = tctxt.m.b8[31]; ctxt->m.b8[29] = tctxt.m.b8[30]; ctxt->m.b8[30] = tctxt.m.b8[29]; ctxt->m.b8[31] = tctxt.m.b8[28]; ctxt->m.b8[32] = tctxt.m.b8[35]; ctxt->m.b8[33] = tctxt.m.b8[34]; ctxt->m.b8[34] = tctxt.m.b8[33]; ctxt->m.b8[35] = tctxt.m.b8[32]; ctxt->m.b8[36] = tctxt.m.b8[39]; ctxt->m.b8[37] = tctxt.m.b8[38]; ctxt->m.b8[38] = tctxt.m.b8[37]; ctxt->m.b8[39] = tctxt.m.b8[36]; ctxt->m.b8[40] = tctxt.m.b8[43]; ctxt->m.b8[41] = tctxt.m.b8[42]; ctxt->m.b8[42] = tctxt.m.b8[41]; ctxt->m.b8[43] = tctxt.m.b8[40]; ctxt->m.b8[44] = tctxt.m.b8[47]; ctxt->m.b8[45] = tctxt.m.b8[46]; ctxt->m.b8[46] = tctxt.m.b8[45]; ctxt->m.b8[47] = tctxt.m.b8[44]; ctxt->m.b8[48] = tctxt.m.b8[51]; ctxt->m.b8[49] = tctxt.m.b8[50]; ctxt->m.b8[50] = tctxt.m.b8[49]; ctxt->m.b8[51] = tctxt.m.b8[48]; ctxt->m.b8[52] = tctxt.m.b8[55]; ctxt->m.b8[53] = tctxt.m.b8[54]; ctxt->m.b8[54] = tctxt.m.b8[53]; ctxt->m.b8[55] = tctxt.m.b8[52]; ctxt->m.b8[56] = tctxt.m.b8[59]; ctxt->m.b8[57] = tctxt.m.b8[58]; ctxt->m.b8[58] = tctxt.m.b8[57]; ctxt->m.b8[59] = tctxt.m.b8[56]; ctxt->m.b8[60] = tctxt.m.b8[63]; ctxt->m.b8[61] = tctxt.m.b8[62]; ctxt->m.b8[62] = tctxt.m.b8[61]; ctxt->m.b8[63] = tctxt.m.b8[60]; #endif a = H(0); b = H(1); c = H(2); d = H(3); e = H(4); for (t = 0; t < 20; t++) { s = t & 0x0f; if (t >= 16) { W(s) = S(1, W((s+13) & 0x0f) ^ W((s+8) & 0x0f) ^ W((s+2) & 0x0f) ^ W(s)); } tmp = S(5, a) + F0(b, c, d) + e + W(s) + K(t); e = d; d = c; c = S(30, b); b = a; a = tmp; } for (t = 20; t < 40; t++) { s = t & 0x0f; W(s) = S(1, W((s+13) & 0x0f) ^ W((s+8) & 0x0f) ^ W((s+2) & 0x0f) ^ W(s)); tmp = S(5, a) + F1(b, c, d) + e + W(s) + K(t); e = d; d = c; c = S(30, b); b = a; a = tmp; } for (t = 40; t < 60; t++) { s = t & 0x0f; W(s) = S(1, W((s+13) & 0x0f) ^ W((s+8) & 0x0f) ^ W((s+2) & 0x0f) ^ W(s)); tmp = S(5, a) + F2(b, c, d) + e + W(s) + K(t); e = d; d = c; c = S(30, b); b = a; a = tmp; } for (t = 60; t < 80; t++) { s = t & 0x0f; W(s) = S(1, W((s+13) & 0x0f) ^ W((s+8) & 0x0f) ^ W((s+2) & 0x0f) ^ W(s)); tmp = S(5, a) + F3(b, c, d) + e + W(s) + K(t); e = d; d = c; c = S(30, b); b = a; a = tmp; } H(0) = H(0) + a; H(1) = H(1) + b; H(2) = H(2) + c; H(3) = H(3) + d; H(4) = H(4) + e; memset(&ctxt->m.b8[0], 0, 64); }
static void reconstruct(double *x, double *y, int len) { double *temp_1, *temp_2; double *even, *odd; int i, n_half, n_unrol; n_half = len >> 1; even = x; odd = x + n_half; temp_1 = y; temp_2 = y + n_half; n_unrol = n_half & 0xfffffff8; for (i = 0; i < n_unrol; i += 8) { even[i + 0] /= NORM_FACTOR; even[i + 1] /= NORM_FACTOR; even[i + 2] /= NORM_FACTOR; even[i + 3] /= NORM_FACTOR; even[i + 4] /= NORM_FACTOR; even[i + 5] /= NORM_FACTOR; even[i + 6] /= NORM_FACTOR; even[i + 7] /= NORM_FACTOR; odd[i + 0] *= NORM_FACTOR; odd[i + 1] *= NORM_FACTOR; odd[i + 2] *= NORM_FACTOR; odd[i + 3] *= NORM_FACTOR; odd[i + 4] *= NORM_FACTOR; odd[i + 5] *= NORM_FACTOR; odd[i + 6] *= NORM_FACTOR; odd[i + 7] *= NORM_FACTOR; } for (; i < n_half; i++) { even[i] /= NORM_FACTOR; odd[i] *= NORM_FACTOR; } PHI3(odd, temp_1, temp_2, n_half); for (i = 0; i < n_unrol; i += 8) { even[i + 0] -= temp_1[i + 0]; even[i + 1] -= temp_1[i + 1]; even[i + 2] -= temp_1[i + 2]; even[i + 3] -= temp_1[i + 3]; even[i + 4] -= temp_1[i + 4]; even[i + 5] -= temp_1[i + 5]; even[i + 6] -= temp_1[i + 6]; even[i + 7] -= temp_1[i + 7]; } for (; i < n_half; i++) even[i] -= temp_1[i]; F2(even, temp_1, temp_2, n_half); for (i = 0; i < n_unrol; i += 8) { odd[i + 0] += temp_1[i + 0]; odd[i + 1] += temp_1[i + 1]; odd[i + 2] += temp_1[i + 2]; odd[i + 3] += temp_1[i + 3]; odd[i + 4] += temp_1[i + 4]; odd[i + 5] += temp_1[i + 5]; odd[i + 6] += temp_1[i + 6]; odd[i + 7] += temp_1[i + 7]; } for (; i < n_half; i++) odd[i] += temp_1[i]; for (i = 0; i < n_unrol; i += 8) { y[((i + 0) << 1)] = even[i + 0]; y[((i + 1) << 1)] = even[i + 1]; y[((i + 2) << 1)] = even[i + 2]; y[((i + 3) << 1)] = even[i + 3]; y[((i + 4) << 1)] = even[i + 4]; y[((i + 5) << 1)] = even[i + 5]; y[((i + 6) << 1)] = even[i + 6]; y[((i + 7) << 1)] = even[i + 7]; y[((i + 0) << 1) + 1] = odd[i + 0]; y[((i + 1) << 1) + 1] = odd[i + 1]; y[((i + 2) << 1) + 1] = odd[i + 2]; y[((i + 3) << 1) + 1] = odd[i + 3]; y[((i + 4) << 1) + 1] = odd[i + 4]; y[((i + 5) << 1) + 1] = odd[i + 5]; y[((i + 6) << 1) + 1] = odd[i + 6]; y[((i + 7) << 1) + 1] = odd[i + 7]; } for (; i < n_half; i++) { y[(i << 1)] = even[i]; y[(i << 1) + 1] = odd[i]; } }
void compareDataCard( TString channel="muTau", TString year="2011", TString Group1="CERN", TString Path1="/afs/cern.ch/user/b/benitezj/public/datacards/2011/Aug4", TString File1="muTauSM_svfitmass", TString Group2="Saclay", TString Path2="/afs/cern.ch/user/b/bianchi/public/Roger/datacards2011v3", TString File2="muTauSM" ){ TFile F1(Path1+"/"+File1+".root","read"); TFile F2(Path2+"/"+File2+".root","read"); F1.ls(); F2.ls(); TString fname="Diff_"+channel+"_"+year+"_"+Group1+"_"+Group2; TCanvas C(fname); C.Print(TString(C.GetName())+".pdf["); //cout<<" | 0jet_low Data | 0jet_low ZTT | 0jet_low W | 0jet_low QCD | 0jet_low TT | 0jet_low ggH | 0jet_low qqH | Boosted_high Data | Boosted_high ZTT | Boosted_high W | Boosted_high QCD | Boosted_high TT | Boosted_high ggH | Boosted_high qqH | VBF Data| VBF ZTT | VBF W | VBF QCD | VBF TT | VBF qqH | VBF ggH |"<<endl; // drawCategory(&C,Group1,&F1,Group2,&F2,channel,"0jet_low",1); // drawCategory(&C,Group1,&F1,Group2,&F2,channel,"0jet_high",0); // drawCategory(&C,Group1,&F1,Group2,&F2,channel,"boost_low",0); // drawCategory(&C,Group1,&F1,Group2,&F2,channel,"boost_high",1); // drawCategory(&C,Group1,&F1,Group2,&F2,channel,"vbf",1); drawSample(&C,Group1,&F1,Group2,&F2,channel,"data_obs",0); drawSample(&C,Group1,&F1,Group2,&F2,channel,"ZTT",0); drawSample(&C,Group1,&F1,Group2,&F2,channel,"W",0); drawSample(&C,Group1,&F1,Group2,&F2,channel,"QCD",0); drawSample(&C,Group1,&F1,Group2,&F2,channel,"TT",0); drawSample(&C,Group1,&F1,Group2,&F2,channel,"ZL",0); drawSample(&C,Group1,&F1,Group2,&F2,channel,"ZJ",0); drawSample(&C,Group1,&F1,Group2,&F2,channel,"ZLL",0); drawSample(&C,Group1,&F1,Group2,&F2,channel,"VV",0); drawSample(&C,Group1,&F1,Group2,&F2,channel,"ggH125",0); drawSample(&C,Group1,&F1,Group2,&F2,channel,"qqH125",0); drawSample(&C,Group1,&F1,Group2,&F2,channel,"VH125",0); // drawSignalDiff(&C,Group1,&F1,Group2,&F2,channel,"boost_high","ggH"); // drawSignalDiff(&C,Group1,&F1,Group2,&F2,channel,"boost_high","qqH"); // drawSignalDiff(&C,Group1,&F1,Group2,&F2,channel,"boost_high","VH"); // drawSignalDiff(&C,Group1,&F1,Group2,&F2,channel,"vbf","ggH"); // drawSignalDiff(&C,Group1,&F1,Group2,&F2,channel,"vbf","qqH"); // drawSignalDiff(&C,Group1,&F1,Group2,&F2,channel,"vbf","VH"); //drawSample(&C,Group1,&F1,Group2,&F2,channel,"ZTT_CMS_scale_t_mutau_8TeVUp",0); //drawSample(&C,Group1,&F1,Group2,&F2,channel,"ZTT_CMS_scale_t_mutau_8TeVDown",0); C.Print(TString(C.GetName())+".pdf]"); //cout<<"|"<<endl; // gROOT->ProcessLine(".q"); }
/* The RIPEMD160 compression function. */ static inline void rmd160_compress(struct rmd160_ctx *ctx, uint32_t *buf) { uint8_t w, round; uint32_t T; uint32_t AL, BL, CL, DL, EL; /* left line */ uint32_t AR, BR, CR, DR, ER; /* right line */ uint32_t X[16]; /* Byte-swap the buffer if we're on a big-endian machine */ cpu_to_le32_array(X, buf, 16); /* Load the left and right lines with the initial state */ AL = AR = ctx->h[0]; BL = BR = ctx->h[1]; CL = CR = ctx->h[2]; DL = DR = ctx->h[3]; EL = ER = ctx->h[4]; /* Round 1 */ round = 0; for (w = 0; w < 16; w++) { /* left line */ T = rol32(AL + F1(BL, CL, DL) + X[RL[round][w]] + KL[round], SL[round][w]) + EL; AL = EL; EL = DL; DL = rol32(CL, 10); CL = BL; BL = T; } for (w = 0; w < 16; w++) { /* right line */ T = rol32(AR + F5(BR, CR, DR) + X[RR[round][w]] + KR[round], SR[round][w]) + ER; AR = ER; ER = DR; DR = rol32(CR, 10); CR = BR; BR = T; } /* Round 2 */ round++; for (w = 0; w < 16; w++) { /* left line */ T = rol32(AL + F2(BL, CL, DL) + X[RL[round][w]] + KL[round], SL[round][w]) + EL; AL = EL; EL = DL; DL = rol32(CL, 10); CL = BL; BL = T; } for (w = 0; w < 16; w++) { /* right line */ T = rol32(AR + F4(BR, CR, DR) + X[RR[round][w]] + KR[round], SR[round][w]) + ER; AR = ER; ER = DR; DR = rol32(CR, 10); CR = BR; BR = T; } /* Round 3 */ round++; for (w = 0; w < 16; w++) { /* left line */ T = rol32(AL + F3(BL, CL, DL) + X[RL[round][w]] + KL[round], SL[round][w]) + EL; AL = EL; EL = DL; DL = rol32(CL, 10); CL = BL; BL = T; } for (w = 0; w < 16; w++) { /* right line */ T = rol32(AR + F3(BR, CR, DR) + X[RR[round][w]] + KR[round], SR[round][w]) + ER; AR = ER; ER = DR; DR = rol32(CR, 10); CR = BR; BR = T; } /* Round 4 */ round++; for (w = 0; w < 16; w++) { /* left line */ T = rol32(AL + F4(BL, CL, DL) + X[RL[round][w]] + KL[round], SL[round][w]) + EL; AL = EL; EL = DL; DL = rol32(CL, 10); CL = BL; BL = T; } for (w = 0; w < 16; w++) { /* right line */ T = rol32(AR + F2(BR, CR, DR) + X[RR[round][w]] + KR[round], SR[round][w]) + ER; AR = ER; ER = DR; DR = rol32(CR, 10); CR = BR; BR = T; } /* Round 5 */ round++; for (w = 0; w < 16; w++) { /* left line */ T = rol32(AL + F5(BL, CL, DL) + X[RL[round][w]] + KL[round], SL[round][w]) + EL; AL = EL; EL = DL; DL = rol32(CL, 10); CL = BL; BL = T; } for (w = 0; w < 16; w++) { /* right line */ T = rol32(AR + F1(BR, CR, DR) + X[RR[round][w]] + KR[round], SR[round][w]) + ER; AR = ER; ER = DR; DR = rol32(CR, 10); CR = BR; BR = T; } /* Final mixing stage */ T = ctx->h[1] + CL + DR; ctx->h[1] = ctx->h[2] + DL + ER; ctx->h[2] = ctx->h[3] + EL + AR; ctx->h[3] = ctx->h[4] + AL + BR; ctx->h[4] = ctx->h[0] + BL + CR; ctx->h[0] = T; }