std::string report(bool useTSV = false) const { std::stringstream s; /* size_t R = size*countsPerLong; s << "R = " << R << std::endl; for (size_t i = 0; i < MAX_TABLE; i++) { int count[4] = {0,0,0,0}; s << "M[" << i << "] = " << M[i]<< std::endl; for (size_t j = 0; j < R; j++) { uint64_t val = getVal(j,i); count[val]++; } s << count[0] << ", " << count[1] << ", " << count[2] << ", " << count[3] << std::endl; } s << std::endl << F0() << std::endl; */ if (useTSV) { s << F0() << "\t" << f1() << "\t" << F1() << std::endl; } else { s << "F0 = " << F0() << std::endl; s << "f1 = " << f1() << std::endl; s << "F1 = " << sumCount << std::endl; } return s.str(); }
Float operator() ( Fun &F , const FloatVector &a , const FloatVector &b , const SizeVector &n , const SizeVector &p , Float &e ) { Float r; typedef IntegrateLast< Fun , SizeVector , FloatVector , Float > IntegrateOne; // check simple vector class specifications CheckSimpleVector<Float, FloatVector>(); // check numeric type specifications CheckNumericType<Float>(); IntegrateOne F0(&F, 0, a, b, n, p); F0.ClearEsum(); F0.ClearEcount(); r = F0(a); assert( F0.GetEcount() == 1 ); e = F0.GetEsum(); return r; }
void DecryptRoundFunction(uint8_t *x, const uint8_t *sk) { uint8_t temp0 = x[0]; x[0] = x[1]; x[1] = x[2] - (F1(x[0]) ^ READ_ROUND_KEY_BYTE(sk[0])); x[2] = x[3]; x[3] = x[4] ^ (F0(x[2]) + READ_ROUND_KEY_BYTE(sk[1])); x[4] = x[5]; x[5] = x[6] - (F1(x[4]) ^ READ_ROUND_KEY_BYTE(sk[2])); x[6] = x[7]; x[7] = temp0 ^ (F0(x[6]) + READ_ROUND_KEY_BYTE(sk[3])); }
void MainInterface::funcbarUpdate(int i) { disconnect(barui ,SLOT(F0())); ui->horizontalLayout->removeWidget(barui); barui->setHidden(true); //delete barui; barui = barmap[i]; barui ->setHidden(false); ui->horizontalLayout->addWidget(barui); connect(this ,SIGNAL(barF0()) ,barui ,SLOT(F0())); emit barF0(); }
std::string report(bool useTSV = false) const { std::stringstream s; if (useTSV) s << F0() << "\t" << f1() << "\t" << F1() << std::endl; else { s << "F0 = " << F0() << std::endl; s << "f1 = " << f1() << std::endl; s << "F1 = " << sumCount << std::endl; } return s.str(); }
void EncryptRoundFunction(uint8_t *x, const uint8_t *sk) { uint8_t temp6 = x[6]; uint8_t temp7 = x[7]; x[7] = x[6]; x[6] = x[5] + (F1(x[4]) ^ READ_ROUND_KEY_BYTE(sk[2])); x[5] = x[4]; x[4] = x[3] ^ (F0(x[2]) + READ_ROUND_KEY_BYTE(sk[1])); x[3] = x[2]; x[2] = x[1] + (F1(x[0]) ^ READ_ROUND_KEY_BYTE(sk[0])); x[1] = x[0]; x[0] = temp7 ^ (F0(temp6) + READ_ROUND_KEY_BYTE(sk[3])); }
int NeoHookeanCompressible3D::revertToStart (void) { tensor F0("I", 2, def_dim_2); F = F0; C = F0; Cinv = F0; J = 1.0; tensor ss_zero(2,def_dim_2,0.0); thisPK2Stress = ss_zero; thisGreenStrain = ss_zero; Stiffness = getInitialTangentTensor(); return 0; }
Foam::tmp<Foam::volScalarField> Foam::dragModels::Tenneti::CdRe() const { volScalarField alpha1 ( max(pair_.dispersed(), pair_.continuous().residualAlpha()) ); volScalarField alpha2 ( max(scalar(1) - pair_.dispersed(), pair_.continuous().residualAlpha()) ); volScalarField F0 ( 5.81*alpha1/pow3(alpha2) + 0.48*pow(alpha1, 1.0/3.0)/pow4(alpha2) ); volScalarField F1 ( pow(alpha1, 3)*max(pair_.Re(), residualRe_) *(0.95 + 0.61*pow3(alpha1)/sqr(alpha2)) ); // Tenneti et al. correlation includes the mean pressure drag. // This was removed here by multiplying F by alpha2 for consistency with // the formulation used in OpenFOAM return SchillerNaumann_->CdRe()/(alpha2*max(pair_.Re(), residualRe_)) + 24.0*sqr(alpha2)*(F0 + F1); }
void FragmentList_print(FILE *outputHandle, uint indent, FragmentNode *fragmentNode) { FragmentEntryNode *fragmentEntryNode; for (fragmentEntryNode = fragmentNode->fragmentEntryList.head; fragmentEntryNode != NULL; fragmentEntryNode = fragmentEntryNode->next) { printSpaces(outputHandle,indent); fprintf(outputHandle,"%8llu..%8llu\n",F0(fragmentEntryNode),F1(fragmentEntryNode)); } }
void FragmentList_debugPrintInfo(FragmentNode *fragmentNode, const char *name) { FragmentEntryNode *fragmentEntryNode; printf("Fragments '%s':\n",name); for (fragmentEntryNode = fragmentNode->fragmentEntryList.head; fragmentEntryNode != NULL; fragmentEntryNode = fragmentEntryNode->next) { printf(" %8llu..%8llu\n",F0(fragmentEntryNode),F1(fragmentEntryNode)); } }
void FileFragmentList_print(FileFragmentNode *fileFragmentNode, const char *name) { FragmentNode *fragmentNode; printf("Fragments '%s':\n",name); for (fragmentNode = fileFragmentNode->fragmentList.head; fragmentNode != NULL; fragmentNode = fragmentNode->next) { printf(" %8llu..%8llu\n",F0(fragmentNode),F1(fragmentNode)); } }
std::string humanReport() const { std::stringstream s; size_t eF0 = F0(); size_t ef1 = f1(); size_t eF1 = sumCount; s << readable(eF0-ef1) << " repeated, " << readable(eF0) << " distinct, " << readable(ef1) << " singletons, " << readable(eF1) << " total k-mers processed"; return s.str(); }
void ScalarDamageInterface2DLaw::FinalizeSolutionStep(const Properties& rMaterialProperties, const GeometryType& rElementGeometry, const Vector& rShapeFunctionsValues, const ProcessInfo& rCurrentProcessInfo) { #ifdef INTERF_DAM_2D_IMPLEX // implicit step // create dummy material parameters Vector dummy_stress(this->GetStrainSize()); Matrix dummy_tangent(this->GetStrainSize(), this->GetStrainSize()); ConstitutiveLaw::Parameters parameters(rElementGeometry, rMaterialProperties, rCurrentProcessInfo); parameters.SetStrainVector( m_strain ); parameters.SetStressVector( dummy_stress ); parameters.SetConstitutiveMatrix( dummy_tangent ); Flags& options = parameters.GetOptions(); options.Set(ConstitutiveLaw::COMPUTE_STRESS, true); options.Set(ConstitutiveLaw::COMPUTE_CONSTITUTIVE_TENSOR, false); options.Set(ConstitutiveLaw::INITIAL_CONFIGURATION); double detF = 1.0; double detF0 = 1.0; Matrix F(IdentityMatrix(2,2)); Matrix F0(IdentityMatrix(2,2)); parameters.SetDeterminantF(detF); parameters.SetDeterminantF0(detF0); parameters.SetDeformationGradientF(F); parameters.SetDeformationGradientF0(F0); // initialize calculation data CalculationData data; InitializeCalculationData(rMaterialProperties, rElementGeometry, m_strain, rCurrentProcessInfo, data); CalculateElasticStressVector( data, m_strain ); // calculate internal variables implicitly CalculateEquivalentMeasure( data ); UpdateDamage( data ); mD1 = data.D1; mD2 = data.D2; // move from n to n-1 mK1_converged_old = mK1_converged; mK2_converged_old = mK2_converged; m_dTime_n_converged = m_dTime_n; #endif // INTERF_DAM_2D_IMPLEX // save converged values mK1_converged = mK1; mK2_converged = mK2; mD2_bar_converged = mD2_bar; }
bool FragmentList_checkEntryExists(FragmentNode *fragmentNode, uint64 offset, uint64 length) { bool existsFlag; uint64 i0,i1; FragmentEntryNode *fragmentEntryNode; assert(fragmentNode != NULL); i0 = I0(offset,length); i1 = I1(offset,length); existsFlag = FALSE; for (fragmentEntryNode = fragmentNode->fragmentEntryList.head; (fragmentEntryNode != NULL) && !existsFlag; fragmentEntryNode = fragmentEntryNode->next) { if ( ((F0(fragmentEntryNode) <= i0) && (i0 <= F1(fragmentEntryNode)) ) || ((F0(fragmentEntryNode) <= i1) && (i1 <= F1(fragmentEntryNode))) ) { existsFlag = TRUE; } } return existsFlag; }
void ConstitutiveModelDriver<EvalT, Traits>:: evaluateFields(typename Traits::EvalData workset) { bool print = false; if (typeid(ScalarT) == typeid(RealType)) print = true; std::cout.precision(15); std::cout << "ConstitutiveModelDriver<EvalT, Traits>::evaluateFields" << std::endl; Intrepid2::Tensor<ScalarT> F(num_dims_), P(num_dims_), sig(num_dims_); Intrepid2::Tensor<ScalarT> F0(num_dims_), P0(num_dims_); for (int cell = 0; cell < workset.numCells; ++cell) { for (int pt = 0; pt < num_pts_; ++pt) { F0.fill(prescribed_def_grad_,cell,pt,0,0); F.fill(def_grad_,cell,pt,0,0); sig.fill(stress_,cell,pt,0,0); P = Intrepid2::piola(F,sig); if (print) { std::cout << "F: \n" << F << std::endl; std::cout << "P: \n" << P << std::endl; std::cout << "sig: \n" << sig << std::endl; } for (int node = 0; node < num_nodes_; ++node) { for (int dim1 = 0; dim1 < num_dims_; ++dim1) { for (int dim2 = 0; dim2 < num_dims_; ++dim2) { residual_(cell,node,dim1,dim2) = (F(dim1,dim2) - F0(dim1,dim2)); //* (P(dim1,dim2) - P0(dim1,dim2)); } } } } } }
static void Sha256ProcessBlock(Sha256Ctx *Ctx, BYTE *block) { unsigned int i; DWORD w[64], temp1, temp2; DWORD a = Ctx->State[0]; DWORD b = Ctx->State[1]; DWORD c = Ctx->State[2]; DWORD d = Ctx->State[3]; DWORD e = Ctx->State[4]; DWORD f = Ctx->State[5]; DWORD g = Ctx->State[6]; DWORD h = Ctx->State[7]; for (i = 0; i < 16; i++) //w[ i ] = GET_UAA32BE(block, i); w[i] = BE32(((DWORD*)block)[i]); for (i = 16; i < 64; i++) w[ i ] = SI4(w[ i - 2 ]) + w[ i - 7 ] + SI3(w[ i - 15 ]) + w[ i - 16 ]; for (i = 0; i < 64; i++) { temp1 = h + SI2(e) + F0(e, f, g) + k[ i ] + w[ i ]; temp2 = SI1(a) + F1(a, b, c); h = g; g = f; f = e; e = d + temp1; d = c; c = b; b = a; a = temp1 + temp2; } Ctx->State[0] += a; Ctx->State[1] += b; Ctx->State[2] += c; Ctx->State[3] += d; Ctx->State[4] += e; Ctx->State[5] += f; Ctx->State[6] += g; Ctx->State[7] += h; }
void MainInterface::initFuncBar() { toplevel *top ; seconlevel_f3 *sec_f3; seconlevel_f4 *sec_f4; seconlevel_f5 *sec_f5; seconlevel_f6 *sec_f6; top = new toplevel(this); top->setHidden(true); connect(top ,SIGNAL(menu(bool)) ,this ,SLOT(menuShow(bool))); sec_f3 = new seconlevel_f3(this); sec_f3 ->setHidden(true); sec_f4 = new seconlevel_f4(this); sec_f4 ->setHidden(true); sec_f5 = new seconlevel_f5(this); sec_f5 ->setHidden(true); sec_f6 = new seconlevel_f6(this); sec_f6 ->setHidden(true); barmap.clear(); barmap.insert(23 ,sec_f3); barmap.insert(24 ,sec_f4); barmap.insert(25 ,sec_f5); barmap.insert(26 ,sec_f6); barmap.insert(28 ,top); barui = barmap[28]; barui->setHidden(false); ui->horizontalLayout->addWidget(barui); connect(this ,SIGNAL(barF0()) ,barui ,SLOT(F0())); connect(spark_info ,SIGNAL(boolChange()) ,this ,SLOT(updateF0())); emit barF0(); }
Foam::tmp<Foam::volScalarField> Foam::dragModels::Tenneti::CdRe() const { volScalarField alpha1 ( max(pair_.dispersed(), pair_.continuous().residualAlpha()) ); volScalarField alpha2 ( max(pair_.continuous(), pair_.continuous().residualAlpha()) ); volScalarField Res(alpha2*pair_.Re()); volScalarField CdReIsolated ( neg(Res - 1000)*24*(1 + 0.15*pow(Res, 0.687)) + pos0(Res - 1000)*0.44*max(Res, residualRe_) ); volScalarField F0 ( 5.81*alpha1/pow3(alpha2) + 0.48*pow(alpha1, 1.0/3.0)/pow4(alpha2) ); volScalarField F1 ( pow3(alpha1)*Res*(0.95 + 0.61*pow3(alpha1)/sqr(alpha2)) ); // Tenneti et al. correlation includes the mean pressure drag. // This was removed here by multiplying F by alpha2 for consistency with // the formulation used in OpenFOAM return CdReIsolated + 24*sqr(alpha2)*(F0 + F1); }
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); }
//---------------------------------------------------------------------------- void SimplePendulum::Stiff2Approximate () { // Approximation with step size 0.05. float h = 0.05f; float x0 = 4.0f/3.0f; float y0 = 2.0f/3.0f; float t0 = 0.0f; const int maxIterations = 20; float* approx0 = new1<float>(maxIterations + 1); float* approx1 = new1<float>(maxIterations + 1); approx0[0] = x0; approx1[0] = y0; int i; for (i = 1; i <= maxIterations; ++i) { float k1X = h*F0(t0, x0, y0); float k1Y = h*F1(t0, x0, y0); float x1 = x0 + 0.5f*k1X; float y1 = y0 + 0.5f*k1Y; float k2X = h*F0(t0 + 0.5f*h, x1, y1); float k2Y = h*F1(t0 + 0.5f*h, x1, y1); x1 = x0 + 0.5f*k2X; y1 = y0 + 0.5f*k2Y; float k3X = h*F0(t0 + 0.5f*h, x1, y1); float k3Y = h*F1(t0 + 0.5f*h, x1, y1); x1 = x0 + k3X; y1 = y0 + k3Y; float k4X = h*F0(t0 + h, x1, y1); float k4Y = h*F1(t0 + h, x1, y1); x1 = x0 + (k1X + 2.0f*k2X + 2.0f*k3X + k4X)/6.0f; y1 = y0 + (k1Y + 2.0f*k2Y + 2.0f*k3Y + k4Y)/6.0f; approx0[i] = x1; approx1[i] = y1; x0 = x1; y0 = y1; t0 += h; } std::string path = Environment::GetPathW("Data/stiff2_appr_h0.05.txt"); std::ofstream outFile(path.c_str()); char message[512]; for (i = 0; i <= maxIterations; ++i) { if ((i % 2) == 0) { sprintf(message, "i = %d, %+8.6f, %+8.6f", i, approx0[i], approx1[i]); outFile << message << std::endl; } } outFile.close(); // Approximation with step size 0.1. h = 0.1f; x0 = 4.0f/3.0f; y0 = 2.0f/3.0f; t0 = 0.0f; approx0[0] = x0; approx1[0] = y0; for (i = 1; i <= maxIterations/2; ++i) { float k1X = h*F0(t0, x0, y0); float k1Y = h*F1(t0, x0, y0); float x1 = x0 + 0.5f*k1X; float y1 = y0 + 0.5f*k1Y; float k2X = h*F0(t0 + 0.5f*h, x1, y1); float k2Y = h*F1(t0 + 0.5f*h, x1, y1); x1 = x0 + 0.5f*k2X; y1 = y0 + 0.5f*k2Y; float k3X = h*F0(t0 + 0.5f*h, x1, y1); float k3Y = h*F1(t0 + 0.5f*h, x1, y1); x1 = x0 + k3X; y1 = y0 + k3Y; float k4X = h*F0(t0 + h, x1, y1); float k4Y = h*F1(t0 + h, x1, y1); x1 = x0 + (k1X + 2.0f*k2X + 2.0f*k3X + k4X)/6.0f; y1 = y0 + (k1Y + 2.0f*k2Y + 2.0f*k3Y + k4Y)/6.0f; approx0[i] = x1; approx1[i] = y1; x0 = x1; y0 = y1; t0 += h; } path = Environment::GetPathW("Data/stiff2_appr_h0.10.txt"); outFile.open(path.c_str()); for (i = 0; i <= maxIterations/2; ++i) { sprintf(message, "i = %d, %+8.6f, %+8.6f", i, approx0[i], approx1[i]); outFile << message << std::endl; } outFile.close(); delete1(approx0); delete1(approx1); }
void Decrypt(uint8_t *block, uint8_t *roundKeys) { int8_t temp0; /* Final Transformation */ temp0 = block[7]; block[7] = block[6] ^ READ_ROUND_KEY_BYTE(roundKeys[7]); block[6] = block[5]; block[5] = block[4] - READ_ROUND_KEY_BYTE(roundKeys[6]); block[4] = block[3]; block[3] = block[2] ^ READ_ROUND_KEY_BYTE(roundKeys[5]); block[2] = block[1]; block[1] = block[0] - READ_ROUND_KEY_BYTE(roundKeys[4]); block[0] = temp0; /* Round 32 - Begin */ temp0 = block[0]; block[0] = block[1]; block[1] = block[2] - (F1(block[0]) ^ READ_ROUND_KEY_BYTE(roundKeys[132])); block[2] = block[3]; block[3] = block[4] ^ (F0(block[2]) + READ_ROUND_KEY_BYTE(roundKeys[133])); block[4] = block[5]; block[5] = block[6] - (F1(block[4]) ^ READ_ROUND_KEY_BYTE(roundKeys[134])); block[6] = block[7]; block[7] = temp0 ^ (F0(block[6]) + READ_ROUND_KEY_BYTE(roundKeys[135])); /* Round 32 - End */ /* Round 31 - Begin */ temp0 = block[0]; block[0] = block[1]; block[1] = block[2] - (F1(block[0]) ^ READ_ROUND_KEY_BYTE(roundKeys[128])); block[2] = block[3]; block[3] = block[4] ^ (F0(block[2]) + READ_ROUND_KEY_BYTE(roundKeys[129])); block[4] = block[5]; block[5] = block[6] - (F1(block[4]) ^ READ_ROUND_KEY_BYTE(roundKeys[130])); block[6] = block[7]; block[7] = temp0 ^ (F0(block[6]) + READ_ROUND_KEY_BYTE(roundKeys[131])); /* Round 31 - End */ /* Round 30 - Begin */ temp0 = block[0]; block[0] = block[1]; block[1] = block[2] - (F1(block[0]) ^ READ_ROUND_KEY_BYTE(roundKeys[124])); block[2] = block[3]; block[3] = block[4] ^ (F0(block[2]) + READ_ROUND_KEY_BYTE(roundKeys[125])); block[4] = block[5]; block[5] = block[6] - (F1(block[4]) ^ READ_ROUND_KEY_BYTE(roundKeys[126])); block[6] = block[7]; block[7] = temp0 ^ (F0(block[6]) + READ_ROUND_KEY_BYTE(roundKeys[127])); /* Round 30 - End */ /* Round 29 - Begin */ temp0 = block[0]; block[0] = block[1]; block[1] = block[2] - (F1(block[0]) ^ READ_ROUND_KEY_BYTE(roundKeys[120])); block[2] = block[3]; block[3] = block[4] ^ (F0(block[2]) + READ_ROUND_KEY_BYTE(roundKeys[121])); block[4] = block[5]; block[5] = block[6] - (F1(block[4]) ^ READ_ROUND_KEY_BYTE(roundKeys[122])); block[6] = block[7]; block[7] = temp0 ^ (F0(block[6]) + READ_ROUND_KEY_BYTE(roundKeys[123])); /* Round 29 - End */ /* Round 28 - Begin */ temp0 = block[0]; block[0] = block[1]; block[1] = block[2] - (F1(block[0]) ^ READ_ROUND_KEY_BYTE(roundKeys[116])); block[2] = block[3]; block[3] = block[4] ^ (F0(block[2]) + READ_ROUND_KEY_BYTE(roundKeys[117])); block[4] = block[5]; block[5] = block[6] - (F1(block[4]) ^ READ_ROUND_KEY_BYTE(roundKeys[118])); block[6] = block[7]; block[7] = temp0 ^ (F0(block[6]) + READ_ROUND_KEY_BYTE(roundKeys[119])); /* Round 28 - End */ /* Round 27 - Begin */ temp0 = block[0]; block[0] = block[1]; block[1] = block[2] - (F1(block[0]) ^ READ_ROUND_KEY_BYTE(roundKeys[112])); block[2] = block[3]; block[3] = block[4] ^ (F0(block[2]) + READ_ROUND_KEY_BYTE(roundKeys[113])); block[4] = block[5]; block[5] = block[6] - (F1(block[4]) ^ READ_ROUND_KEY_BYTE(roundKeys[114])); block[6] = block[7]; block[7] = temp0 ^ (F0(block[6]) + READ_ROUND_KEY_BYTE(roundKeys[115])); /* Round 27 - End */ /* Round 26 - Begin */ temp0 = block[0]; block[0] = block[1]; block[1] = block[2] - (F1(block[0]) ^ READ_ROUND_KEY_BYTE(roundKeys[108])); block[2] = block[3]; block[3] = block[4] ^ (F0(block[2]) + READ_ROUND_KEY_BYTE(roundKeys[109])); block[4] = block[5]; block[5] = block[6] - (F1(block[4]) ^ READ_ROUND_KEY_BYTE(roundKeys[110])); block[6] = block[7]; block[7] = temp0 ^ (F0(block[6]) + READ_ROUND_KEY_BYTE(roundKeys[111])); /* Round 26 - End */ /* Round 25 - Begin */ temp0 = block[0]; block[0] = block[1]; block[1] = block[2] - (F1(block[0]) ^ READ_ROUND_KEY_BYTE(roundKeys[104])); block[2] = block[3]; block[3] = block[4] ^ (F0(block[2]) + READ_ROUND_KEY_BYTE(roundKeys[105])); block[4] = block[5]; block[5] = block[6] - (F1(block[4]) ^ READ_ROUND_KEY_BYTE(roundKeys[106])); block[6] = block[7]; block[7] = temp0 ^ (F0(block[6]) + READ_ROUND_KEY_BYTE(roundKeys[107])); /* Round 25 - End */ /* Round 24 - Begin */ temp0 = block[0]; block[0] = block[1]; block[1] = block[2] - (F1(block[0]) ^ READ_ROUND_KEY_BYTE(roundKeys[100])); block[2] = block[3]; block[3] = block[4] ^ (F0(block[2]) + READ_ROUND_KEY_BYTE(roundKeys[101])); block[4] = block[5]; block[5] = block[6] - (F1(block[4]) ^ READ_ROUND_KEY_BYTE(roundKeys[102])); block[6] = block[7]; block[7] = temp0 ^ (F0(block[6]) + READ_ROUND_KEY_BYTE(roundKeys[103])); /* Round 24 - End */ /* Round 23 - Begin */ temp0 = block[0]; block[0] = block[1]; block[1] = block[2] - (F1(block[0]) ^ READ_ROUND_KEY_BYTE(roundKeys[96])); block[2] = block[3]; block[3] = block[4] ^ (F0(block[2]) + READ_ROUND_KEY_BYTE(roundKeys[97])); block[4] = block[5]; block[5] = block[6] - (F1(block[4]) ^ READ_ROUND_KEY_BYTE(roundKeys[98])); block[6] = block[7]; block[7] = temp0 ^ (F0(block[6]) + READ_ROUND_KEY_BYTE(roundKeys[99])); /* Round 23 - End */ /* Round 22 - Begin */ temp0 = block[0]; block[0] = block[1]; block[1] = block[2] - (F1(block[0]) ^ READ_ROUND_KEY_BYTE(roundKeys[92])); block[2] = block[3]; block[3] = block[4] ^ (F0(block[2]) + READ_ROUND_KEY_BYTE(roundKeys[93])); block[4] = block[5]; block[5] = block[6] - (F1(block[4]) ^ READ_ROUND_KEY_BYTE(roundKeys[94])); block[6] = block[7]; block[7] = temp0 ^ (F0(block[6]) + READ_ROUND_KEY_BYTE(roundKeys[95])); /* Round 22 - End */ /* Round 21 - Begin */ temp0 = block[0]; block[0] = block[1]; block[1] = block[2] - (F1(block[0]) ^ READ_ROUND_KEY_BYTE(roundKeys[88])); block[2] = block[3]; block[3] = block[4] ^ (F0(block[2]) + READ_ROUND_KEY_BYTE(roundKeys[89])); block[4] = block[5]; block[5] = block[6] - (F1(block[4]) ^ READ_ROUND_KEY_BYTE(roundKeys[90])); block[6] = block[7]; block[7] = temp0 ^ (F0(block[6]) + READ_ROUND_KEY_BYTE(roundKeys[91])); /* Round 21 - End */ /* Round 20 - Begin */ temp0 = block[0]; block[0] = block[1]; block[1] = block[2] - (F1(block[0]) ^ READ_ROUND_KEY_BYTE(roundKeys[84])); block[2] = block[3]; block[3] = block[4] ^ (F0(block[2]) + READ_ROUND_KEY_BYTE(roundKeys[85])); block[4] = block[5]; block[5] = block[6] - (F1(block[4]) ^ READ_ROUND_KEY_BYTE(roundKeys[86])); block[6] = block[7]; block[7] = temp0 ^ (F0(block[6]) + READ_ROUND_KEY_BYTE(roundKeys[87])); /* Round 20 - End */ /* Round 19 - Begin */ temp0 = block[0]; block[0] = block[1]; block[1] = block[2] - (F1(block[0]) ^ READ_ROUND_KEY_BYTE(roundKeys[80])); block[2] = block[3]; block[3] = block[4] ^ (F0(block[2]) + READ_ROUND_KEY_BYTE(roundKeys[81])); block[4] = block[5]; block[5] = block[6] - (F1(block[4]) ^ READ_ROUND_KEY_BYTE(roundKeys[82])); block[6] = block[7]; block[7] = temp0 ^ (F0(block[6]) + READ_ROUND_KEY_BYTE(roundKeys[83])); /* Round 19 - End */ /* Round 18 - Begin */ temp0 = block[0]; block[0] = block[1]; block[1] = block[2] - (F1(block[0]) ^ READ_ROUND_KEY_BYTE(roundKeys[76])); block[2] = block[3]; block[3] = block[4] ^ (F0(block[2]) + READ_ROUND_KEY_BYTE(roundKeys[77])); block[4] = block[5]; block[5] = block[6] - (F1(block[4]) ^ READ_ROUND_KEY_BYTE(roundKeys[78])); block[6] = block[7]; block[7] = temp0 ^ (F0(block[6]) + READ_ROUND_KEY_BYTE(roundKeys[79])); /* Round 18 - End */ /* Round 17 - Begin */ temp0 = block[0]; block[0] = block[1]; block[1] = block[2] - (F1(block[0]) ^ READ_ROUND_KEY_BYTE(roundKeys[72])); block[2] = block[3]; block[3] = block[4] ^ (F0(block[2]) + READ_ROUND_KEY_BYTE(roundKeys[73])); block[4] = block[5]; block[5] = block[6] - (F1(block[4]) ^ READ_ROUND_KEY_BYTE(roundKeys[74])); block[6] = block[7]; block[7] = temp0 ^ (F0(block[6]) + READ_ROUND_KEY_BYTE(roundKeys[75])); /* Round 17 - End */ /* Round 16 - Begin */ temp0 = block[0]; block[0] = block[1]; block[1] = block[2] - (F1(block[0]) ^ READ_ROUND_KEY_BYTE(roundKeys[68])); block[2] = block[3]; block[3] = block[4] ^ (F0(block[2]) + READ_ROUND_KEY_BYTE(roundKeys[69])); block[4] = block[5]; block[5] = block[6] - (F1(block[4]) ^ READ_ROUND_KEY_BYTE(roundKeys[70])); block[6] = block[7]; block[7] = temp0 ^ (F0(block[6]) + READ_ROUND_KEY_BYTE(roundKeys[71])); /* Round 16 - End */ /* Round 15 - Begin */ temp0 = block[0]; block[0] = block[1]; block[1] = block[2] - (F1(block[0]) ^ READ_ROUND_KEY_BYTE(roundKeys[64])); block[2] = block[3]; block[3] = block[4] ^ (F0(block[2]) + READ_ROUND_KEY_BYTE(roundKeys[65])); block[4] = block[5]; block[5] = block[6] - (F1(block[4]) ^ READ_ROUND_KEY_BYTE(roundKeys[66])); block[6] = block[7]; block[7] = temp0 ^ (F0(block[6]) + READ_ROUND_KEY_BYTE(roundKeys[67])); /* Round 15 - End */ /* Round 14 - Begin */ temp0 = block[0]; block[0] = block[1]; block[1] = block[2] - (F1(block[0]) ^ READ_ROUND_KEY_BYTE(roundKeys[60])); block[2] = block[3]; block[3] = block[4] ^ (F0(block[2]) + READ_ROUND_KEY_BYTE(roundKeys[61])); block[4] = block[5]; block[5] = block[6] - (F1(block[4]) ^ READ_ROUND_KEY_BYTE(roundKeys[62])); block[6] = block[7]; block[7] = temp0 ^ (F0(block[6]) + READ_ROUND_KEY_BYTE(roundKeys[63])); /* Round 14 - End */ /* Round 13 - Begin */ temp0 = block[0]; block[0] = block[1]; block[1] = block[2] - (F1(block[0]) ^ READ_ROUND_KEY_BYTE(roundKeys[56])); block[2] = block[3]; block[3] = block[4] ^ (F0(block[2]) + READ_ROUND_KEY_BYTE(roundKeys[57])); block[4] = block[5]; block[5] = block[6] - (F1(block[4]) ^ READ_ROUND_KEY_BYTE(roundKeys[58])); block[6] = block[7]; block[7] = temp0 ^ (F0(block[6]) + READ_ROUND_KEY_BYTE(roundKeys[59])); /* Round 13 - End */ /* Round 12 - Begin */ temp0 = block[0]; block[0] = block[1]; block[1] = block[2] - (F1(block[0]) ^ READ_ROUND_KEY_BYTE(roundKeys[52])); block[2] = block[3]; block[3] = block[4] ^ (F0(block[2]) + READ_ROUND_KEY_BYTE(roundKeys[53])); block[4] = block[5]; block[5] = block[6] - (F1(block[4]) ^ READ_ROUND_KEY_BYTE(roundKeys[54])); block[6] = block[7]; block[7] = temp0 ^ (F0(block[6]) + READ_ROUND_KEY_BYTE(roundKeys[55])); /* Round 12 - End */ /* Round 11 - Begin */ temp0 = block[0]; block[0] = block[1]; block[1] = block[2] - (F1(block[0]) ^ READ_ROUND_KEY_BYTE(roundKeys[48])); block[2] = block[3]; block[3] = block[4] ^ (F0(block[2]) + READ_ROUND_KEY_BYTE(roundKeys[49])); block[4] = block[5]; block[5] = block[6] - (F1(block[4]) ^ READ_ROUND_KEY_BYTE(roundKeys[50])); block[6] = block[7]; block[7] = temp0 ^ (F0(block[6]) + READ_ROUND_KEY_BYTE(roundKeys[51])); /* Round 11 - End */ /* Round 10 - Begin */ temp0 = block[0]; block[0] = block[1]; block[1] = block[2] - (F1(block[0]) ^ READ_ROUND_KEY_BYTE(roundKeys[44])); block[2] = block[3]; block[3] = block[4] ^ (F0(block[2]) + READ_ROUND_KEY_BYTE(roundKeys[45])); block[4] = block[5]; block[5] = block[6] - (F1(block[4]) ^ READ_ROUND_KEY_BYTE(roundKeys[46])); block[6] = block[7]; block[7] = temp0 ^ (F0(block[6]) + READ_ROUND_KEY_BYTE(roundKeys[47])); /* Round 10 - End */ /* Round 9 - Begin */ temp0 = block[0]; block[0] = block[1]; block[1] = block[2] - (F1(block[0]) ^ READ_ROUND_KEY_BYTE(roundKeys[40])); block[2] = block[3]; block[3] = block[4] ^ (F0(block[2]) + READ_ROUND_KEY_BYTE(roundKeys[41])); block[4] = block[5]; block[5] = block[6] - (F1(block[4]) ^ READ_ROUND_KEY_BYTE(roundKeys[42])); block[6] = block[7]; block[7] = temp0 ^ (F0(block[6]) + READ_ROUND_KEY_BYTE(roundKeys[43])); /* Round 9 - End */ /* Round 8 - Begin */ temp0 = block[0]; block[0] = block[1]; block[1] = block[2] - (F1(block[0]) ^ READ_ROUND_KEY_BYTE(roundKeys[36])); block[2] = block[3]; block[3] = block[4] ^ (F0(block[2]) + READ_ROUND_KEY_BYTE(roundKeys[37])); block[4] = block[5]; block[5] = block[6] - (F1(block[4]) ^ READ_ROUND_KEY_BYTE(roundKeys[38])); block[6] = block[7]; block[7] = temp0 ^ (F0(block[6]) + READ_ROUND_KEY_BYTE(roundKeys[39])); /* Round 8 - End */ /* Round 7 - Begin */ temp0 = block[0]; block[0] = block[1]; block[1] = block[2] - (F1(block[0]) ^ READ_ROUND_KEY_BYTE(roundKeys[32])); block[2] = block[3]; block[3] = block[4] ^ (F0(block[2]) + READ_ROUND_KEY_BYTE(roundKeys[33])); block[4] = block[5]; block[5] = block[6] - (F1(block[4]) ^ READ_ROUND_KEY_BYTE(roundKeys[34])); block[6] = block[7]; block[7] = temp0 ^ (F0(block[6]) + READ_ROUND_KEY_BYTE(roundKeys[35])); /* Round 7 - End */ /* Round 6 - Begin */ temp0 = block[0]; block[0] = block[1]; block[1] = block[2] - (F1(block[0]) ^ READ_ROUND_KEY_BYTE(roundKeys[28])); block[2] = block[3]; block[3] = block[4] ^ (F0(block[2]) + READ_ROUND_KEY_BYTE(roundKeys[29])); block[4] = block[5]; block[5] = block[6] - (F1(block[4]) ^ READ_ROUND_KEY_BYTE(roundKeys[30])); block[6] = block[7]; block[7] = temp0 ^ (F0(block[6]) + READ_ROUND_KEY_BYTE(roundKeys[31])); /* Round 6 - End */ /* Round 5 - Begin */ temp0 = block[0]; block[0] = block[1]; block[1] = block[2] - (F1(block[0]) ^ READ_ROUND_KEY_BYTE(roundKeys[24])); block[2] = block[3]; block[3] = block[4] ^ (F0(block[2]) + READ_ROUND_KEY_BYTE(roundKeys[25])); block[4] = block[5]; block[5] = block[6] - (F1(block[4]) ^ READ_ROUND_KEY_BYTE(roundKeys[26])); block[6] = block[7]; block[7] = temp0 ^ (F0(block[6]) + READ_ROUND_KEY_BYTE(roundKeys[27])); /* Round 5 - End */ /* Round 4 - Begin */ temp0 = block[0]; block[0] = block[1]; block[1] = block[2] - (F1(block[0]) ^ READ_ROUND_KEY_BYTE(roundKeys[20])); block[2] = block[3]; block[3] = block[4] ^ (F0(block[2]) + READ_ROUND_KEY_BYTE(roundKeys[21])); block[4] = block[5]; block[5] = block[6] - (F1(block[4]) ^ READ_ROUND_KEY_BYTE(roundKeys[22])); block[6] = block[7]; block[7] = temp0 ^ (F0(block[6]) + READ_ROUND_KEY_BYTE(roundKeys[23])); /* Round 4 - End */ /* Round 3 - Begin */ temp0 = block[0]; block[0] = block[1]; block[1] = block[2] - (F1(block[0]) ^ READ_ROUND_KEY_BYTE(roundKeys[16])); block[2] = block[3]; block[3] = block[4] ^ (F0(block[2]) + READ_ROUND_KEY_BYTE(roundKeys[17])); block[4] = block[5]; block[5] = block[6] - (F1(block[4]) ^ READ_ROUND_KEY_BYTE(roundKeys[18])); block[6] = block[7]; block[7] = temp0 ^ (F0(block[6]) + READ_ROUND_KEY_BYTE(roundKeys[19])); /* Round 3 - End */ /* Round 2 - Begin */ temp0 = block[0]; block[0] = block[1]; block[1] = block[2] - (F1(block[0]) ^ READ_ROUND_KEY_BYTE(roundKeys[12])); block[2] = block[3]; block[3] = block[4] ^ (F0(block[2]) + READ_ROUND_KEY_BYTE(roundKeys[13])); block[4] = block[5]; block[5] = block[6] - (F1(block[4]) ^ READ_ROUND_KEY_BYTE(roundKeys[14])); block[6] = block[7]; block[7] = temp0 ^ (F0(block[6]) + READ_ROUND_KEY_BYTE(roundKeys[15])); /* Round 2 - End */ /* Round 1 - Begin */ temp0 = block[0]; block[0] = block[1]; block[1] = block[2] - (F1(block[0]) ^ READ_ROUND_KEY_BYTE(roundKeys[8])); block[2] = block[3]; block[3] = block[4] ^ (F0(block[2]) + READ_ROUND_KEY_BYTE(roundKeys[9])); block[4] = block[5]; block[5] = block[6] - (F1(block[4]) ^ READ_ROUND_KEY_BYTE(roundKeys[10])); block[6] = block[7]; block[7] = temp0 ^ (F0(block[6]) + READ_ROUND_KEY_BYTE(roundKeys[11])); /* Round 1 - End */ /* Initial Transformation */ block[0] = block[0] - READ_ROUND_KEY_BYTE(roundKeys[0]); block[2] = block[2] ^ READ_ROUND_KEY_BYTE(roundKeys[1]); block[4] = block[4] - READ_ROUND_KEY_BYTE(roundKeys[2]); block[6] = block[6] ^ READ_ROUND_KEY_BYTE(roundKeys[3]); }
QString VScalar::propertyString() const { return tr("%2 frame %3 of %1 = %4", "%2 is field name. %3 is frame/index. %1 is the file name. %4 is the value").arg(dataSource()->fileName()).arg(field()).arg(F0()).arg(value()); }
void FragmentList_addEntry(FragmentNode *fragmentNode, uint64 offset, uint64 length) { FragmentEntryNode *fragmentEntryNode,*deleteFragmentEntryNode; FragmentEntryNode *prevFragmentEntryNode,*nextFragmentEntryNode; assert(fragmentNode != NULL); /* remove all fragments which are completely covered by new fragment */ fragmentEntryNode = fragmentNode->fragmentEntryList.head; while (fragmentEntryNode != NULL) { if ((F0(fragmentEntryNode) >= I0(offset,length)) && (F1(fragmentEntryNode) <= I1(offset,length))) { deleteFragmentEntryNode = fragmentEntryNode; fragmentEntryNode = fragmentEntryNode->next; List_remove(&fragmentNode->fragmentEntryList,deleteFragmentEntryNode); LIST_DELETE_NODE(deleteFragmentEntryNode); } else { fragmentEntryNode = fragmentEntryNode->next; } } /* find prev/next fragment */ prevFragmentEntryNode = NULL; fragmentEntryNode = fragmentNode->fragmentEntryList.head; while ((fragmentEntryNode != NULL) && (F1(fragmentEntryNode) < I1(offset,length))) { prevFragmentEntryNode = fragmentEntryNode; fragmentEntryNode = fragmentEntryNode->next; } nextFragmentEntryNode = NULL; fragmentEntryNode = fragmentNode->fragmentEntryList.tail; while ((fragmentEntryNode != NULL) && (F0(fragmentEntryNode) > I0(offset,length))) { nextFragmentEntryNode = fragmentEntryNode; fragmentEntryNode = fragmentEntryNode->prev; } /* check if existing Fragment can be extended or new Fragment have to be inserted */ if ((prevFragmentEntryNode != NULL) && (F1(prevFragmentEntryNode)+1 >= I0(offset,length))) { /* combine with previous existing fragment */ prevFragmentEntryNode->length = (offset+length)-prevFragmentEntryNode->offset; prevFragmentEntryNode->offset = prevFragmentEntryNode->offset; } else if ((nextFragmentEntryNode != NULL) && (I1(offset,length)+1 >= F0(nextFragmentEntryNode))) { /* combine with next existing fragment */ nextFragmentEntryNode->length = (nextFragmentEntryNode->offset+nextFragmentEntryNode->length)-offset; nextFragmentEntryNode->offset = offset; } else { /* insert new Fragment */ fragmentEntryNode = LIST_NEW_NODE(FragmentEntryNode); if (fragmentEntryNode == NULL) { HALT_INSUFFICIENT_MEMORY(); } fragmentEntryNode->offset = offset; fragmentEntryNode->length = length; List_insert(&fragmentNode->fragmentEntryList,fragmentEntryNode,nextFragmentEntryNode); } }
QString VScalar::descriptionTip() const { QString IDstring; IDstring = tr( "Data Scalar: %1 = %4\n" " %2\n" " Field: %3\n" " Frame: %5" ).arg(Name()).arg(dataSource()->fileName()).arg(field()).arg(value()).arg(F0()); return IDstring; }
/* This is a simple example of multi-dimensional integration using a simple (not necessarily optimal) spacing of points. Note that this doesn't perform any error estimation - it only calculates the value for a given grid size. */ double IntegrateExample_dumb( int functionCode, int n, // How many points on each dimension const float *a, // An array of k lower bounds const float *b, // An array of k upper bounds const float *params // Parameters to function ){ int k=-1, total=-1, i0, i1, i2, j; // Accumulate in double, as it avoids floating-point errors when adding large // numbers of values together. Note that using double in a GPU has implications, // as some GPUs cannot do doubles, and on others they are much slower than floats double acc=0; //float *x=NULL; int n0=n, n1=n, n2=n; // By default use n points in each dimension switch(functionCode){ case 0: k=1; break; case 1: k=2; break; case 2: k=3; break; case 3: k=3; break; case 4: k=3; break; case 5: k=3; break; case 6: k=3; break; default: fprintf(stderr, "Invalid function code."); exit(1); } // Collapse any dimensions we don't use if(k<3){ n2=1; } if(k<2){ n1=1; } float* x = new float[k]; // Loop over highest dimension on outside, as it might be collapsed to zero for(i2=0;i2<n2;i2++){ if(k>2){ x[2]=a[2]+(b[2]-a[2]) * (i2+0.5f)/n2; } for(i1=0;i1<n1;i1++){ if(k>1){ x[1]=a[1]+(b[1]-a[1]) * (i1+0.5f)/n1; } // Inner dimension is never collapsed to zero for(i0=0;i0<n0;i0++){ x[0]=a[0]+(b[0]-a[0]) * (i0+0.5f)/n0; // Now call the function. Note that it is rather // inefficient to be choosing the function in the inner loop... // MAKE A FUNCTION POINTER FURTHER UP THEN USE IT!!!! switch(functionCode){ case 0: acc+=F0(x,params); break; case 1: acc+=F1(x,params); break; case 2: acc+=F2(x,params); break; case 3: acc+=F3(x,params); break; case 4: acc+=F4(x,params); break; case 5: acc+=F5(x,params); break; case 6: acc+=F6(x,params); break; } } } } // Do the final normalisation and return the results for(j=0;j<k;j++){ acc=acc*(b[j]-a[j]); } return acc/(n0*n1*n2); }
void test_forward() { forward(F0(), get<A&>(), get<A const&>(), get<A>(), get<const A>(), get<A&&>(), get<const A&&>()); forward(F0(), get<A&>(), get<A const&>(), get<A>(), get<const A>(), // expected-note{{in instantiation of function template specialization 'perfect_forwarding::forward<perfect_forwarding::F0, perfect_forwarding::A &, const perfect_forwarding::A &, perfect_forwarding::A, const perfect_forwarding::A, const perfect_forwarding::A, const perfect_forwarding::A>' requested here}} get<const A&&>(), get<const A&&>()); }
QString VScalar::propertyString() const { return i18n("%2 frame %3 of %1 = %4").arg(dataSource()->fileName()).arg(field()).arg(F0()).arg(value()); }
static int internal_coalesce(void) { BlockP block; BlockP previous; BlockP tail; #ifndef BLOCKS_GUARDED BlockP bin_copy[NBINS+2]; #endif size_t size; /* where size is used to specify an element of an array it should really be * called index, but to generate better code I got rid of the index variable */ F0("!!internal_coalesce..."); #ifdef STATS statsP->stats.coalesces++; #endif lookInBins = FALSE; totalFree = 0; /* set bins and overflow lists to empty */ for (size = 0; size <= NBINS+1; size++) { bin[size] = NULL; #ifndef BLOCKS_GUARDED bin_copy[size] = NULL; #endif } block = heapLow; /* NULL indicates previous doesn't point to start of free block */ previous = NULL; tail = NULL; while (block <= heapHigh) { if (INVALID(block)) return CORRUPT; if (FREE(block)) { /* free block */ if (previous == NULL) previous = block; } else if (previous != NULL) { size = PTRDIFF(block, previous) - OVERHEAD; /* set flags to Free */ totalFree += size; previous->size = (size | FREEBIT); if (size <= MAXBINSIZE) { /* return to bin */ size /= BINRANGE; if (bin[size] == NULL) bin[size] = previous; else { /* if not BLOCKS_GUARDED use guard word of first block in bin to hold * a pointer to the last block in the list for this bin otherwise * use the bin_copy array. This allows me to keep the list in * ascending address order. Remember to put back the guard words at * the end of coalescing if BLOCKS_GUARDED. */ #ifdef BLOCKS_GUARDED ((BlockP) bin[size]->guard)->next = previous; #else (bin_copy[size])->next = previous; #endif } #ifdef BLOCKS_GUARDED bin[size]->guard = (int) previous; #else bin_copy[size] = previous; #endif } else { /* put block on overflow list */ if (bin[0] == NULL) {bin[0] = previous; previous->previous = NULL;} else {tail->next = previous; previous->previous = tail;} tail = previous; } previous = NULL; } ADDBYTESTO(block, SIZE(block) + OVERHEAD); } /* replace the guard words at the start of the bins lists */ for (size = 1; size <= NBINS; size++) { if (bin[size] != NULL) { lookInBins = TRUE; #ifdef BLOCKS_GUARDED ((BlockP) bin[size]->guard)->next = NULL; bin[size]->guard = GUARDCONSTANT; #else (bin_copy[size])->next = NULL; #endif } } /* do both ends of overflow list */ if (bin[0] != NULL) { tail->next = NULL; bin[NBINS+1] = tail; } else { bin[NBINS+1] = NULL; } lastFreeBlockOnHeap = bin[NBINS+1]; F0(" ... complete\n"); return OK; }