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