static void serpent_encrypt(struct crypto_tfm *tfm, u8 *dst, const u8 *src)
{
struct serpent_ctx *ctx = crypto_tfm_ctx(tfm);
const u32
*k = ctx->expkey;
const __le32 *s = (const __le32 *)src;
__le32 *d = (__le32 *)dst;
u32 r0, r1, r2, r3, r4;
/*
* Note: The conversions between u8* and u32* might cause trouble
* on architectures with stricter alignment rules than x86
*/
r0 = le32_to_cpu(s[0]);
r1 = le32_to_cpu(s[1]);
r2 = le32_to_cpu(s[2]);
r3 = le32_to_cpu(s[3]);
K(r0,r1,r2,r3,0);
S0(r0,r1,r2,r3,r4); LK(r2,r1,r3,r0,r4,1);
S1(r2,r1,r3,r0,r4); LK(r4,r3,r0,r2,r1,2);
S2(r4,r3,r0,r2,r1); LK(r1,r3,r4,r2,r0,3);
S3(r1,r3,r4,r2,r0); LK(r2,r0,r3,r1,r4,4);
S4(r2,r0,r3,r1,r4); LK(r0,r3,r1,r4,r2,5);
S5(r0,r3,r1,r4,r2); LK(r2,r0,r3,r4,r1,6);
S6(r2,r0,r3,r4,r1); LK(r3,r1,r0,r4,r2,7);
S7(r3,r1,r0,r4,r2); LK(r2,r0,r4,r3,r1,8);
S0(r2,r0,r4,r3,r1); LK(r4,r0,r3,r2,r1,9);
S1(r4,r0,r3,r2,r1); LK(r1,r3,r2,r4,r0,10);
S2(r1,r3,r2,r4,r0); LK(r0,r3,r1,r4,r2,11);
S3(r0,r3,r1,r4,r2); LK(r4,r2,r3,r0,r1,12);
S4(r4,r2,r3,r0,r1); LK(r2,r3,r0,r1,r4,13);
S5(r2,r3,r0,r1,r4); LK(r4,r2,r3,r1,r0,14);
S6(r4,r2,r3,r1,r0); LK(r3,r0,r2,r1,r4,15);
S7(r3,r0,r2,r1,r4); LK(r4,r2,r1,r3,r0,16);
S0(r4,r2,r1,r3,r0); LK(r1,r2,r3,r4,r0,17);
S1(r1,r2,r3,r4,r0); LK(r0,r3,r4,r1,r2,18);
S2(r0,r3,r4,r1,r2); LK(r2,r3,r0,r1,r4,19);
S3(r2,r3,r0,r1,r4); LK(r1,r4,r3,r2,r0,20);
S4(r1,r4,r3,r2,r0); LK(r4,r3,r2,r0,r1,21);
S5(r4,r3,r2,r0,r1); LK(r1,r4,r3,r0,r2,22);
S6(r1,r4,r3,r0,r2); LK(r3,r2,r4,r0,r1,23);
S7(r3,r2,r4,r0,r1); LK(r1,r4,r0,r3,r2,24);
S0(r1,r4,r0,r3,r2); LK(r0,r4,r3,r1,r2,25);
S1(r0,r4,r3,r1,r2); LK(r2,r3,r1,r0,r4,26);
S2(r2,r3,r1,r0,r4); LK(r4,r3,r2,r0,r1,27);
S3(r4,r3,r2,r0,r1); LK(r0,r1,r3,r4,r2,28);
S4(r0,r1,r3,r4,r2); LK(r1,r3,r4,r2,r0,29);
S5(r1,r3,r4,r2,r0); LK(r0,r1,r3,r2,r4,30);
S6(r0,r1,r3,r2,r4); LK(r3,r4,r1,r2,r0,31);
S7(r3,r4,r1,r2,r0); K(r0,r1,r2,r3,32);
d[0] = cpu_to_le32(r0);
d[1] = cpu_to_le32(r1);
d[2] = cpu_to_le32(r2);
d[3] = cpu_to_le32(r3);
}
void test()
{
/* Scattering iterators. */
int c1;
/* Original iterators. */
int i;
S1();
S3(0);
S2();
S3(1);
}
void test(int M)
{
/* Original iterators. */
int i, j;
S3(2,1) ;
S1(3,1) ;
S1(4,1) ;
S4(4,2) ;
for (i=5;i<=M+1;i++) {
S1(i,1) ;
for (j=2;j<=floord(i-1,2);j++) {
S2(i,j) ;
}
if (i%2 == 0) {
S4(i,i/2) ;
}
}
for (i=M+2;i<=2*M-1;i++) {
for (j=i-M;j<=floord(i-1,2);j++) {
S2(i,j) ;
}
if (i%2 == 0) {
S4(i,i/2) ;
}
}
i = 2*M ;
S4(2*M,M) ;
}
void _stdcall serpent256_encrypt(const unsigned char *in, unsigned char *out, serpent256_key *key)
{
u32 *k = key->expkey;
u32 r0, r1, r2, r3, r4;
r0 = p32(in)[0]; r1 = p32(in)[1];
r2 = p32(in)[2]; r3 = p32(in)[3];
K(r0,r1,r2,r3,0);
S0(r0,r1,r2,r3,r4); LK(r2,r1,r3,r0,r4,1);
S1(r2,r1,r3,r0,r4); LK(r4,r3,r0,r2,r1,2);
S2(r4,r3,r0,r2,r1); LK(r1,r3,r4,r2,r0,3);
S3(r1,r3,r4,r2,r0); LK(r2,r0,r3,r1,r4,4);
S4(r2,r0,r3,r1,r4); LK(r0,r3,r1,r4,r2,5);
S5(r0,r3,r1,r4,r2); LK(r2,r0,r3,r4,r1,6);
S6(r2,r0,r3,r4,r1); LK(r3,r1,r0,r4,r2,7);
S7(r3,r1,r0,r4,r2); LK(r2,r0,r4,r3,r1,8);
S0(r2,r0,r4,r3,r1); LK(r4,r0,r3,r2,r1,9);
S1(r4,r0,r3,r2,r1); LK(r1,r3,r2,r4,r0,10);
S2(r1,r3,r2,r4,r0); LK(r0,r3,r1,r4,r2,11);
S3(r0,r3,r1,r4,r2); LK(r4,r2,r3,r0,r1,12);
S4(r4,r2,r3,r0,r1); LK(r2,r3,r0,r1,r4,13);
S5(r2,r3,r0,r1,r4); LK(r4,r2,r3,r1,r0,14);
S6(r4,r2,r3,r1,r0); LK(r3,r0,r2,r1,r4,15);
S7(r3,r0,r2,r1,r4); LK(r4,r2,r1,r3,r0,16);
S0(r4,r2,r1,r3,r0); LK(r1,r2,r3,r4,r0,17);
S1(r1,r2,r3,r4,r0); LK(r0,r3,r4,r1,r2,18);
S2(r0,r3,r4,r1,r2); LK(r2,r3,r0,r1,r4,19);
S3(r2,r3,r0,r1,r4); LK(r1,r4,r3,r2,r0,20);
S4(r1,r4,r3,r2,r0); LK(r4,r3,r2,r0,r1,21);
S5(r4,r3,r2,r0,r1); LK(r1,r4,r3,r0,r2,22);
S6(r1,r4,r3,r0,r2); LK(r3,r2,r4,r0,r1,23);
S7(r3,r2,r4,r0,r1); LK(r1,r4,r0,r3,r2,24);
S0(r1,r4,r0,r3,r2); LK(r0,r4,r3,r1,r2,25);
S1(r0,r4,r3,r1,r2); LK(r2,r3,r1,r0,r4,26);
S2(r2,r3,r1,r0,r4); LK(r4,r3,r2,r0,r1,27);
S3(r4,r3,r2,r0,r1); LK(r0,r1,r3,r4,r2,28);
S4(r0,r1,r3,r4,r2); LK(r1,r3,r4,r2,r0,29);
S5(r1,r3,r4,r2,r0); LK(r0,r1,r3,r2,r4,30);
S6(r0,r1,r3,r2,r4); LK(r3,r4,r1,r2,r0,31);
S7(r3,r4,r1,r2,r0); K(r0,r1,r2,r3,32);
p32(out)[0] = r0; p32(out)[1] = r1;
p32(out)[2] = r2; p32(out)[3] = r3;
}
inline void UntilTask::OnTaskUpdate(const StateEntry& update) {
if(m_state == 4) {
if(update.m_state == State::FAILED) {
return S3(update);
} else if(IsTerminal(update.m_state)) {
return S1(update);
}
}
}
int sc_main(int ac, char *av[])
{
//Signals
sc_signal<double> in1;
sc_signal<double> in2;
sc_signal<double> sum;
sc_signal<double> diff;
sc_signal<double> prod;
sc_signal<double> quot;
sc_signal<double> powr;
//Clock
sc_signal<bool> clk;
numgen N("numgen"); //instance of `numgen' module
N(in1, in2, clk ); //Positional port binding
stage1 S1("stage1"); //instance of `stage1' module
//Named port binding
S1.in1(in1);
S1.in2(in2);
S1.sum(sum);
S1.diff(diff);
S1.clk(clk);
stage2 S2("stage2"); //instance of `stage2' module
S2(sum, diff, prod, quot, clk ); //Positional port binding
stage3 S3("stage3"); //instance of `stage3' module
S3( prod, quot, powr, clk); //Positional port binding
display D("display"); //instance of `display' module
D(powr, clk); //Positional port binding
sc_start(0, SC_NS); //Initialize simulation
for (int i = 0; i < 50; i++)
{
clk.write(1);
sc_start( 10, SC_NS );
clk.write(0);
sc_start( 10, SC_NS );
}
return 0;
}
inline void SpawnTask::OnTrigger(const Expect<void>& value) {
if(m_state != 1) {
return;
}
try {
value.Get();
} catch(const std::exception& e) {
return S3(StateEntry(State::FAILED, e.what()));
}
return S4();
}
void tuple_apply_test()
{
typedef std::tuple<int, int> tuple2_type;
typedef std::tuple<int, int, long> tuple3_type;
{
tuple2_type t(1,2);
CHECK_EQUAL_VALUE(3, falcon::tuple_apply(falcon::plus<int>(), t));
falcon::plus<int> f;
CHECK_EQUAL_VALUE(3, falcon::tuple_apply(f, t));
CHECK_EQUAL_VALUE(3, falcon::tuple_apply(falcon::plus<int>(), tuple2_type(1,2)));
}
{
tuple3_type t(1,2,60);
CHECK_EQUAL_VALUE(30, falcon::tuple_apply(S3(), t));
CHECK_EQUAL_VALUE(0, falcon::tuple_apply(falcon::parameter_index<0,2,1>(), S3(), t));
CHECK_EQUAL_VALUE(0, falcon::tuple_apply(falcon::parameter_index<0,2,1>(), S3(), tuple3_type(1,2,60)));
}
}
void test()
{
/* Original iterators. */
int i, j;
for (i=0;i<=3;i++) {
S1(i,i) ;
S2(i,i) ;
for (j=i+1;j<=4;j++) {
S2(i,j) ;
}
S2(i,5) ;
S3(i,5) ;
}
S1(4,4) ;
S2(4,4) ;
S2(4,5) ;
S3(4,5) ;
S1(5,5) ;
S2(5,5) ;
S3(5,5) ;
}
inline void UntilTask::OnCondition(const Expect<bool>& condition) {
if(m_state == 0) {
try {
if(condition.Get()) {
return S1(StateEntry(State::COMPLETE));
} else {
return S2();
}
} catch(const std::exception& e) {
return S3(StateEntry(State::FAILED, e.what()));
}
} else if(m_state == 4) {
try {
if(condition.Get()) {
return S1(StateEntry(State::COMPLETE));
}
} catch(const std::exception& e) {
return S3(StateEntry(State::FAILED, e.what()));
}
}
}
static void __serpent_setkey_sbox(u32 r0, u32 r1, u32 r2, u32 r3, u32 r4, u32 *k)
{
k += 100;
S3(r3, r4, r0, r1, r2); store_and_load_keys(r1, r2, r4, r3, 28, 24);
S4(r1, r2, r4, r3, r0); store_and_load_keys(r2, r4, r3, r0, 24, 20);
S5(r2, r4, r3, r0, r1); store_and_load_keys(r1, r2, r4, r0, 20, 16);
S6(r1, r2, r4, r0, r3); store_and_load_keys(r4, r3, r2, r0, 16, 12);
S7(r4, r3, r2, r0, r1); store_and_load_keys(r1, r2, r0, r4, 12, 8);
S0(r1, r2, r0, r4, r3); store_and_load_keys(r0, r2, r4, r1, 8, 4);
S1(r0, r2, r4, r1, r3); store_and_load_keys(r3, r4, r1, r0, 4, 0);
S2(r3, r4, r1, r0, r2); store_and_load_keys(r2, r4, r3, r0, 0, -4);
S3(r2, r4, r3, r0, r1); store_and_load_keys(r0, r1, r4, r2, -4, -8);
S4(r0, r1, r4, r2, r3); store_and_load_keys(r1, r4, r2, r3, -8, -12);
S5(r1, r4, r2, r3, r0); store_and_load_keys(r0, r1, r4, r3, -12, -16);
S6(r0, r1, r4, r3, r2); store_and_load_keys(r4, r2, r1, r3, -16, -20);
S7(r4, r2, r1, r3, r0); store_and_load_keys(r0, r1, r3, r4, -20, -24);
S0(r0, r1, r3, r4, r2); store_and_load_keys(r3, r1, r4, r0, -24, -28);
k -= 50;
S1(r3, r1, r4, r0, r2); store_and_load_keys(r2, r4, r0, r3, 22, 18);
S2(r2, r4, r0, r3, r1); store_and_load_keys(r1, r4, r2, r3, 18, 14);
S3(r1, r4, r2, r3, r0); store_and_load_keys(r3, r0, r4, r1, 14, 10);
S4(r3, r0, r4, r1, r2); store_and_load_keys(r0, r4, r1, r2, 10, 6);
S5(r0, r4, r1, r2, r3); store_and_load_keys(r3, r0, r4, r2, 6, 2);
S6(r3, r0, r4, r2, r1); store_and_load_keys(r4, r1, r0, r2, 2, -2);
S7(r4, r1, r0, r2, r3); store_and_load_keys(r3, r0, r2, r4, -2, -6);
S0(r3, r0, r2, r4, r1); store_and_load_keys(r2, r0, r4, r3, -6, -10);
S1(r2, r0, r4, r3, r1); store_and_load_keys(r1, r4, r3, r2, -10, -14);
S2(r1, r4, r3, r2, r0); store_and_load_keys(r0, r4, r1, r2, -14, -18);
S3(r0, r4, r1, r2, r3); store_and_load_keys(r2, r3, r4, r0, -18, -22);
k -= 50;
S4(r2, r3, r4, r0, r1); store_and_load_keys(r3, r4, r0, r1, 28, 24);
S5(r3, r4, r0, r1, r2); store_and_load_keys(r2, r3, r4, r1, 24, 20);
S6(r2, r3, r4, r1, r0); store_and_load_keys(r4, r0, r3, r1, 20, 16);
S7(r4, r0, r3, r1, r2); store_and_load_keys(r2, r3, r1, r4, 16, 12);
S0(r2, r3, r1, r4, r0); store_and_load_keys(r1, r3, r4, r2, 12, 8);
S1(r1, r3, r4, r2, r0); store_and_load_keys(r0, r4, r2, r1, 8, 4);
S2(r0, r4, r2, r1, r3); store_and_load_keys(r3, r4, r0, r1, 4, 0);
S3(r3, r4, r0, r1, r2); storekeys(r1, r2, r4, r3, 0);
}
void vpTemplateTrackerWarp::warpTriangle(const vpTemplateTrackerTriangle &in,const vpColVector &p, vpTemplateTrackerTriangle &out)
{
if (p.size() < 2) {
vpCTRACE << "Bad template tracker warp parameters dimension. Should never occur. " << std::endl;
throw(vpException(vpException::dimensionError, "Bad template tracker warp parameters dimension"));
}
vpColVector S1(2),S2(2),S3(2);
vpColVector rS1(2),rS2(2),rS3(2);
in.getCorners(S1,S2,S3);
computeDenom(S1,p);
warpX(S1,rS1,p);
computeDenom(S2,p);
warpX(S2,rS2,p);
computeDenom(S3,p);
warpX(S3,rS3,p);
out.init(rS1,rS2,rS3);
}
/**
Use state machine
S0: start status
S1: / status
S2: /. status
S3: /abc status
S4: /.. status
END: end status
ERROR: end status
enum
{
E_STATE_S0,
E_STATE_S1,
E_STATE_S2,
E_STATE_S3,
E_STATE_S4,
E_STATE_END,
E_STATE_ERROR
} m_eStatue;
*/
string Solution::simplifyPath(string path)
{
stack<int> stkSlashes;
int i = 0;
int j = -1;
if(path.empty())
return string();
m_eStatue = E_STATE_S0;
bool bFinished = false;
while(!bFinished)
{
switch(m_eStatue)
{
case E_STATE_S0:
S0(path, i, j, stkSlashes);
break;
case E_STATE_S1:
S1(path, i, j, stkSlashes);
break;
case E_STATE_S2:
S2(path, i, j, stkSlashes);
break;
case E_STATE_S3:
S3(path, i, j, stkSlashes);
break;
case E_STATE_S4:
S4(path, i, j, stkSlashes);
break;
case E_STATE_END:
bFinished = true;
break;
case E_STATE_ERROR:
bFinished = true;
break;
default:
break;
}
}
return path;
}
TEST_F(statearray, slicing) {
StateArray A(3, dl, dataptr);
StateArray S0(A,0);
StateArray S1(A,1);
StateArray S2(A,2);
StateArray S3(A,3);
ASSERT_EQ(S0.size(), A.size());
ASSERT_EQ(S1.size(), A.size()-1);
ASSERT_EQ(S2.size(), A.size()-2);
ASSERT_EQ(S3.size(), A.size()-3);
ASSERT_TRUE(A[0] != A[1]);
ASSERT_EQ(A[0].data_ptr(), S0[0].data_ptr());
ASSERT_EQ(A[1].data_ptr(), S0[1].data_ptr());
ASSERT_EQ(A[2].data_ptr(), S0[2].data_ptr());
ASSERT_EQ(A[1].data_ptr(), S1[0].data_ptr());
ASSERT_EQ(A[2].data_ptr(), S1[1].data_ptr());
ASSERT_EQ(A[2].data_ptr(), S2[0].data_ptr());
StateArray S11(A,1,1);
ASSERT_EQ(S11.size(), 1u);
ASSERT_EQ(A[1].data_ptr(), S11[0].data_ptr());
}
int sc_main(int ac, char *av[])
{
sc_signal<double> in1;
sc_signal<double> in2;
sc_signal<double> sum;
sc_signal<double> diff;
sc_signal<double> prod;
sc_signal<double> quot;
sc_signal<double> powr;
powr = 0.0;
sc_clock clk("CLOCK", 20.0, SC_NS, 0.5, 0.0, SC_NS);
numgen N("STIMULUS", clk, in1, in2);
stage1 S1("Stage1", clk, in1, in2, sum, diff);
stage2 S2("Stage2", clk, sum, diff, prod, quot);
stage3 S3("Stage3", clk, prod, quot, powr);
display D("Display", clk, powr);
sc_start(1000, SC_NS);
return 0;
}
static void _BRSHA512Compress(uint64_t *r, uint64_t *x)
{
static const uint64_t k[] = {
0x428a2f98d728ae22, 0x7137449123ef65cd, 0xb5c0fbcfec4d3b2f, 0xe9b5dba58189dbbc, 0x3956c25bf348b538,
0x59f111f1b605d019, 0x923f82a4af194f9b, 0xab1c5ed5da6d8118, 0xd807aa98a3030242, 0x12835b0145706fbe,
0x243185be4ee4b28c, 0x550c7dc3d5ffb4e2, 0x72be5d74f27b896f, 0x80deb1fe3b1696b1, 0x9bdc06a725c71235,
0xc19bf174cf692694, 0xe49b69c19ef14ad2, 0xefbe4786384f25e3, 0x0fc19dc68b8cd5b5, 0x240ca1cc77ac9c65,
0x2de92c6f592b0275, 0x4a7484aa6ea6e483, 0x5cb0a9dcbd41fbd4, 0x76f988da831153b5, 0x983e5152ee66dfab,
0xa831c66d2db43210, 0xb00327c898fb213f, 0xbf597fc7beef0ee4, 0xc6e00bf33da88fc2, 0xd5a79147930aa725,
0x06ca6351e003826f, 0x142929670a0e6e70, 0x27b70a8546d22ffc, 0x2e1b21385c26c926, 0x4d2c6dfc5ac42aed,
0x53380d139d95b3df, 0x650a73548baf63de, 0x766a0abb3c77b2a8, 0x81c2c92e47edaee6, 0x92722c851482353b,
0xa2bfe8a14cf10364, 0xa81a664bbc423001, 0xc24b8b70d0f89791, 0xc76c51a30654be30, 0xd192e819d6ef5218,
0xd69906245565a910, 0xf40e35855771202a, 0x106aa07032bbd1b8, 0x19a4c116b8d2d0c8, 0x1e376c085141ab53,
0x2748774cdf8eeb99, 0x34b0bcb5e19b48a8, 0x391c0cb3c5c95a63, 0x4ed8aa4ae3418acb, 0x5b9cca4f7763e373,
0x682e6ff3d6b2b8a3, 0x748f82ee5defb2fc, 0x78a5636f43172f60, 0x84c87814a1f0ab72, 0x8cc702081a6439ec,
0x90befffa23631e28, 0xa4506cebde82bde9, 0xbef9a3f7b2c67915, 0xc67178f2e372532b, 0xca273eceea26619c,
0xd186b8c721c0c207, 0xeada7dd6cde0eb1e, 0xf57d4f7fee6ed178, 0x06f067aa72176fba, 0x0a637dc5a2c898a6,
0x113f9804bef90dae, 0x1b710b35131c471b, 0x28db77f523047d84, 0x32caab7b40c72493, 0x3c9ebe0a15c9bebc,
0x431d67c49c100d4c, 0x4cc5d4becb3e42b6, 0x597f299cfc657e2a, 0x5fcb6fab3ad6faec, 0x6c44198c4a475817
};
int i;
uint64_t a = r[0], b = r[1], c = r[2], d = r[3], e = r[4], f = r[5], g = r[6], h = r[7], t1, t2, w[80];
for (i = 0; i < 16; i++) w[i] = be64(x[i]);
for (; i < 80; i++) w[i] = S3(w[i - 2]) + w[i - 7] + S2(w[i - 15]) + w[i - 16];
for (i = 0; i < 80; i++) {
t1 = h + S1(e) + ch(e, f, g) + k[i] + w[i];
t2 = S0(a) + maj(a, b, c);
h = g, g = f, f = e, e = d + t1, d = c, c = b, b = a, a = t1 + t2;
}
r[0] += a, r[1] += b, r[2] += c, r[3] += d, r[4] += e, r[5] += f, r[6] += g, r[7] += h;
var_clean(&a, &b, &c, &d, &e, &f, &g, &h, &t1, &t2);
mem_clean(w, sizeof(w));
}
int __serpent_setkey(struct serpent_ctx *ctx, const u8 *key,
unsigned int keylen)
{
u32 *k = ctx->expkey;
u8 *k8 = (u8 *)k;
u32 r0, r1, r2, r3, r4;
int i;
/* Copy key, add padding */
for (i = 0; i < keylen; ++i)
k8[i] = key[i];
if (i < SERPENT_MAX_KEY_SIZE)
k8[i++] = 1;
while (i < SERPENT_MAX_KEY_SIZE)
k8[i++] = 0;
/* Expand key using polynomial */
r0 = le32_to_cpu(k[3]);
r1 = le32_to_cpu(k[4]);
r2 = le32_to_cpu(k[5]);
r3 = le32_to_cpu(k[6]);
r4 = le32_to_cpu(k[7]);
keyiter(le32_to_cpu(k[0]), r0, r4, r2, 0, 0);
keyiter(le32_to_cpu(k[1]), r1, r0, r3, 1, 1);
keyiter(le32_to_cpu(k[2]), r2, r1, r4, 2, 2);
keyiter(le32_to_cpu(k[3]), r3, r2, r0, 3, 3);
keyiter(le32_to_cpu(k[4]), r4, r3, r1, 4, 4);
keyiter(le32_to_cpu(k[5]), r0, r4, r2, 5, 5);
keyiter(le32_to_cpu(k[6]), r1, r0, r3, 6, 6);
keyiter(le32_to_cpu(k[7]), r2, r1, r4, 7, 7);
keyiter(k[0], r3, r2, r0, 8, 8);
keyiter(k[1], r4, r3, r1, 9, 9);
keyiter(k[2], r0, r4, r2, 10, 10);
keyiter(k[3], r1, r0, r3, 11, 11);
keyiter(k[4], r2, r1, r4, 12, 12);
keyiter(k[5], r3, r2, r0, 13, 13);
keyiter(k[6], r4, r3, r1, 14, 14);
keyiter(k[7], r0, r4, r2, 15, 15);
keyiter(k[8], r1, r0, r3, 16, 16);
keyiter(k[9], r2, r1, r4, 17, 17);
keyiter(k[10], r3, r2, r0, 18, 18);
keyiter(k[11], r4, r3, r1, 19, 19);
keyiter(k[12], r0, r4, r2, 20, 20);
keyiter(k[13], r1, r0, r3, 21, 21);
keyiter(k[14], r2, r1, r4, 22, 22);
keyiter(k[15], r3, r2, r0, 23, 23);
keyiter(k[16], r4, r3, r1, 24, 24);
keyiter(k[17], r0, r4, r2, 25, 25);
keyiter(k[18], r1, r0, r3, 26, 26);
keyiter(k[19], r2, r1, r4, 27, 27);
keyiter(k[20], r3, r2, r0, 28, 28);
keyiter(k[21], r4, r3, r1, 29, 29);
keyiter(k[22], r0, r4, r2, 30, 30);
keyiter(k[23], r1, r0, r3, 31, 31);
k += 50;
keyiter(k[-26], r2, r1, r4, 32, -18);
keyiter(k[-25], r3, r2, r0, 33, -17);
keyiter(k[-24], r4, r3, r1, 34, -16);
keyiter(k[-23], r0, r4, r2, 35, -15);
keyiter(k[-22], r1, r0, r3, 36, -14);
keyiter(k[-21], r2, r1, r4, 37, -13);
keyiter(k[-20], r3, r2, r0, 38, -12);
keyiter(k[-19], r4, r3, r1, 39, -11);
keyiter(k[-18], r0, r4, r2, 40, -10);
keyiter(k[-17], r1, r0, r3, 41, -9);
keyiter(k[-16], r2, r1, r4, 42, -8);
keyiter(k[-15], r3, r2, r0, 43, -7);
keyiter(k[-14], r4, r3, r1, 44, -6);
keyiter(k[-13], r0, r4, r2, 45, -5);
keyiter(k[-12], r1, r0, r3, 46, -4);
keyiter(k[-11], r2, r1, r4, 47, -3);
keyiter(k[-10], r3, r2, r0, 48, -2);
keyiter(k[-9], r4, r3, r1, 49, -1);
keyiter(k[-8], r0, r4, r2, 50, 0);
keyiter(k[-7], r1, r0, r3, 51, 1);
keyiter(k[-6], r2, r1, r4, 52, 2);
keyiter(k[-5], r3, r2, r0, 53, 3);
keyiter(k[-4], r4, r3, r1, 54, 4);
keyiter(k[-3], r0, r4, r2, 55, 5);
keyiter(k[-2], r1, r0, r3, 56, 6);
keyiter(k[-1], r2, r1, r4, 57, 7);
keyiter(k[0], r3, r2, r0, 58, 8);
keyiter(k[1], r4, r3, r1, 59, 9);
keyiter(k[2], r0, r4, r2, 60, 10);
keyiter(k[3], r1, r0, r3, 61, 11);
keyiter(k[4], r2, r1, r4, 62, 12);
keyiter(k[5], r3, r2, r0, 63, 13);
keyiter(k[6], r4, r3, r1, 64, 14);
keyiter(k[7], r0, r4, r2, 65, 15);
keyiter(k[8], r1, r0, r3, 66, 16);
keyiter(k[9], r2, r1, r4, 67, 17);
keyiter(k[10], r3, r2, r0, 68, 18);
keyiter(k[11], r4, r3, r1, 69, 19);
keyiter(k[12], r0, r4, r2, 70, 20);
keyiter(k[13], r1, r0, r3, 71, 21);
keyiter(k[14], r2, r1, r4, 72, 22);
keyiter(k[15], r3, r2, r0, 73, 23);
keyiter(k[16], r4, r3, r1, 74, 24);
keyiter(k[17], r0, r4, r2, 75, 25);
keyiter(k[18], r1, r0, r3, 76, 26);
keyiter(k[19], r2, r1, r4, 77, 27);
keyiter(k[20], r3, r2, r0, 78, 28);
keyiter(k[21], r4, r3, r1, 79, 29);
keyiter(k[22], r0, r4, r2, 80, 30);
keyiter(k[23], r1, r0, r3, 81, 31);
k += 50;
keyiter(k[-26], r2, r1, r4, 82, -18);
keyiter(k[-25], r3, r2, r0, 83, -17);
keyiter(k[-24], r4, r3, r1, 84, -16);
keyiter(k[-23], r0, r4, r2, 85, -15);
keyiter(k[-22], r1, r0, r3, 86, -14);
keyiter(k[-21], r2, r1, r4, 87, -13);
keyiter(k[-20], r3, r2, r0, 88, -12);
keyiter(k[-19], r4, r3, r1, 89, -11);
keyiter(k[-18], r0, r4, r2, 90, -10);
keyiter(k[-17], r1, r0, r3, 91, -9);
keyiter(k[-16], r2, r1, r4, 92, -8);
keyiter(k[-15], r3, r2, r0, 93, -7);
keyiter(k[-14], r4, r3, r1, 94, -6);
keyiter(k[-13], r0, r4, r2, 95, -5);
keyiter(k[-12], r1, r0, r3, 96, -4);
keyiter(k[-11], r2, r1, r4, 97, -3);
keyiter(k[-10], r3, r2, r0, 98, -2);
keyiter(k[-9], r4, r3, r1, 99, -1);
keyiter(k[-8], r0, r4, r2, 100, 0);
keyiter(k[-7], r1, r0, r3, 101, 1);
keyiter(k[-6], r2, r1, r4, 102, 2);
keyiter(k[-5], r3, r2, r0, 103, 3);
keyiter(k[-4], r4, r3, r1, 104, 4);
keyiter(k[-3], r0, r4, r2, 105, 5);
keyiter(k[-2], r1, r0, r3, 106, 6);
keyiter(k[-1], r2, r1, r4, 107, 7);
keyiter(k[0], r3, r2, r0, 108, 8);
keyiter(k[1], r4, r3, r1, 109, 9);
keyiter(k[2], r0, r4, r2, 110, 10);
keyiter(k[3], r1, r0, r3, 111, 11);
keyiter(k[4], r2, r1, r4, 112, 12);
keyiter(k[5], r3, r2, r0, 113, 13);
keyiter(k[6], r4, r3, r1, 114, 14);
keyiter(k[7], r0, r4, r2, 115, 15);
keyiter(k[8], r1, r0, r3, 116, 16);
keyiter(k[9], r2, r1, r4, 117, 17);
keyiter(k[10], r3, r2, r0, 118, 18);
keyiter(k[11], r4, r3, r1, 119, 19);
keyiter(k[12], r0, r4, r2, 120, 20);
keyiter(k[13], r1, r0, r3, 121, 21);
keyiter(k[14], r2, r1, r4, 122, 22);
keyiter(k[15], r3, r2, r0, 123, 23);
keyiter(k[16], r4, r3, r1, 124, 24);
keyiter(k[17], r0, r4, r2, 125, 25);
keyiter(k[18], r1, r0, r3, 126, 26);
keyiter(k[19], r2, r1, r4, 127, 27);
keyiter(k[20], r3, r2, r0, 128, 28);
keyiter(k[21], r4, r3, r1, 129, 29);
keyiter(k[22], r0, r4, r2, 130, 30);
keyiter(k[23], r1, r0, r3, 131, 31);
/* Apply S-boxes */
S3(r3, r4, r0, r1, r2); store_and_load_keys(r1, r2, r4, r3, 28, 24);
S4(r1, r2, r4, r3, r0); store_and_load_keys(r2, r4, r3, r0, 24, 20);
S5(r2, r4, r3, r0, r1); store_and_load_keys(r1, r2, r4, r0, 20, 16);
S6(r1, r2, r4, r0, r3); store_and_load_keys(r4, r3, r2, r0, 16, 12);
S7(r4, r3, r2, r0, r1); store_and_load_keys(r1, r2, r0, r4, 12, 8);
S0(r1, r2, r0, r4, r3); store_and_load_keys(r0, r2, r4, r1, 8, 4);
S1(r0, r2, r4, r1, r3); store_and_load_keys(r3, r4, r1, r0, 4, 0);
S2(r3, r4, r1, r0, r2); store_and_load_keys(r2, r4, r3, r0, 0, -4);
S3(r2, r4, r3, r0, r1); store_and_load_keys(r0, r1, r4, r2, -4, -8);
S4(r0, r1, r4, r2, r3); store_and_load_keys(r1, r4, r2, r3, -8, -12);
S5(r1, r4, r2, r3, r0); store_and_load_keys(r0, r1, r4, r3, -12, -16);
S6(r0, r1, r4, r3, r2); store_and_load_keys(r4, r2, r1, r3, -16, -20);
S7(r4, r2, r1, r3, r0); store_and_load_keys(r0, r1, r3, r4, -20, -24);
S0(r0, r1, r3, r4, r2); store_and_load_keys(r3, r1, r4, r0, -24, -28);
k -= 50;
S1(r3, r1, r4, r0, r2); store_and_load_keys(r2, r4, r0, r3, 22, 18);
S2(r2, r4, r0, r3, r1); store_and_load_keys(r1, r4, r2, r3, 18, 14);
S3(r1, r4, r2, r3, r0); store_and_load_keys(r3, r0, r4, r1, 14, 10);
S4(r3, r0, r4, r1, r2); store_and_load_keys(r0, r4, r1, r2, 10, 6);
S5(r0, r4, r1, r2, r3); store_and_load_keys(r3, r0, r4, r2, 6, 2);
S6(r3, r0, r4, r2, r1); store_and_load_keys(r4, r1, r0, r2, 2, -2);
S7(r4, r1, r0, r2, r3); store_and_load_keys(r3, r0, r2, r4, -2, -6);
S0(r3, r0, r2, r4, r1); store_and_load_keys(r2, r0, r4, r3, -6, -10);
S1(r2, r0, r4, r3, r1); store_and_load_keys(r1, r4, r3, r2, -10, -14);
S2(r1, r4, r3, r2, r0); store_and_load_keys(r0, r4, r1, r2, -14, -18);
S3(r0, r4, r1, r2, r3); store_and_load_keys(r2, r3, r4, r0, -18, -22);
k -= 50;
S4(r2, r3, r4, r0, r1); store_and_load_keys(r3, r4, r0, r1, 28, 24);
S5(r3, r4, r0, r1, r2); store_and_load_keys(r2, r3, r4, r1, 24, 20);
S6(r2, r3, r4, r1, r0); store_and_load_keys(r4, r0, r3, r1, 20, 16);
S7(r4, r0, r3, r1, r2); store_and_load_keys(r2, r3, r1, r4, 16, 12);
S0(r2, r3, r1, r4, r0); store_and_load_keys(r1, r3, r4, r2, 12, 8);
S1(r1, r3, r4, r2, r0); store_and_load_keys(r0, r4, r2, r1, 8, 4);
S2(r0, r4, r2, r1, r3); store_and_load_keys(r3, r4, r0, r1, 4, 0);
S3(r3, r4, r0, r1, r2); storekeys(r1, r2, r4, r3, 0);
return 0;
}
constexpr S2(const S2&) = default; // expected-error {{defaulted definition of copy constructor is not constexpr}}
constexpr S2(S2&&) = default; // expected-error {{defaulted definition of move constructor is not constexpr}}
NoCopyMove ncm;
};
// If a function is explicitly defaulted on its first declaration
// -- it is implicitly considered to be constexpr if the implicit declaration
// would be
struct S3 {
S3() = default; // expected-note {{here}}
S3(const S3&) = default;
S3(S3&&) = default;
constexpr S3(int n) : n(n) {}
int n;
};
constexpr S3 s3a = S3(0);
constexpr S3 s3b = s3a;
constexpr S3 s3c = S3(); // expected-error {{constant expression}} expected-note {{non-constexpr constructor}}
struct S4 {
S4() = default;
S4(const S4&) = default; // expected-note {{here}}
S4(S4&&) = default; // expected-note {{here}}
NoCopyMove ncm;
};
constexpr S4 s4a; // ok
constexpr S4 s4b = S4(); // expected-error {{constant expression}} expected-note {{non-constexpr constructor}}
constexpr S4 s4c = s4a; // expected-error {{constant expression}} expected-note {{non-constexpr constructor}}
struct S5 {
constexpr S5();
TEST( Commission , EquivalenceClass )
{
srand(time(NULL));
for( int times = 0 ; times < 100000 ; ++times )
{
vector<tuple<int,int,int>> dataSets;
int sets = rand()%10+5;
bool VALID_FLAG = true;
bool TERM_FLAG = false;
bool LOCK_ERR_FLAG = false ,STOCK_ERR_FLAG = false ,BARREL_ERR_FLAG = false;
for( int i = 0 ; i < sets ; ++i )
{
int l = num() , s = num() , b = num();
if( !L1(l) || !S1(s) || !B1(b) )
VALID_FLAG = false;
if( L2(l) ) TERM_FLAG = true;
if( L3(l) || L4(l) ) LOCK_ERR_FLAG = true;
if( S2(s) || S3(s) ) STOCK_ERR_FLAG = true;
if( B2(b) || B3(b) ) BARREL_ERR_FLAG = true;
dataSets.emplace_back(make_tuple(l,s,b));
if( TERM_FLAG ) break;
}
//add terminator
if( !TERM_FLAG )
if( num() % 4 != 3 ) // 75% chance
{
dataSets.emplace_back(make_tuple(-1,0,0));
TERM_FLAG = true;
}
else
VALID_FLAG = false;
// for any error, result will be invalid
if( LOCK_ERR_FLAG || STOCK_ERR_FLAG || BARREL_ERR_FLAG || !TERM_FLAG )
VALID_FLAG = false;
double result = retrieve(dataSets);
if( VALID_FLAG == true )
{
ASSERT_TRUE( 0 <= result ) << "Result is Valid but return error";
}
else
{
// error code must match the flag
switch(cms_error_code) {
case TERM_ERROR:
ASSERT_TRUE(!TERM_FLAG);
break;
case LOCK_ERROR:
ASSERT_TRUE(LOCK_ERR_FLAG);
break;
case STOCK_ERROR:
ASSERT_TRUE(STOCK_ERR_FLAG);
break;
case BARREL_ERROR:
ASSERT_TRUE(BARREL_ERR_FLAG);
break;
case OK:
break;
default:
ASSERT_TRUE(false) << "Fatel Error ,Code = " << cms_error_code << endl;
}
}
}
}
mlib_status
mlib_ImagePolynomialWarp_0_BC(
mlib_image *dst,
const mlib_image *src,
mlib_d64 wx,
mlib_d64 wy)
{
mlib_d64 a0, a1, a2, a3;
mlib_d64 r0, r1, r2, r3, res;
mlib_d64 fx0, fx1, fx2, fx3;
mlib_d64 fy0, fy1, fy2, fy3;
mlib_d64 dx, dy;
mlib_s32 i, srcYStride, srcChannels, color[4];
mlib_type srcType;
mlib_d64 limit_lo, limit_hi;
srcType = mlib_ImageGetType(src);
srcYStride = mlib_ImageGetStride(src);
srcChannels = mlib_ImageGetChannels(src);
dx = wx - (mlib_s32)wx;
dy = wy - (mlib_s32)wy;
fx0 = S0(dx);
fx1 = S1(dx);
fx2 = S2(dx);
fx3 = S3(dx);
fy0 = S0(dy);
fy1 = S1(dy);
fy2 = S2(dy);
fy3 = S3(dy);
switch (srcType) {
case MLIB_BYTE:
{
mlib_u8 *srcData0, *srcData = mlib_ImageGetData(src);
limit_lo = MLIB_U8_MIN;
limit_hi = MLIB_U8_MAX;
srcData = srcData + ((mlib_s32)wy - 1) * srcYStride;
srcData += ((mlib_s32)wx - 1) * srcChannels;
CALC_BICUBIC;
}
break;
case MLIB_SHORT:
{
mlib_s16 *srcData0, *srcData = mlib_ImageGetData(src);
limit_lo = MLIB_S16_MIN;
limit_hi = MLIB_S16_MAX;
srcData =
(void *)((mlib_u8 *)srcData + ((mlib_s32)wy -
1) * srcYStride);
srcData += ((mlib_s32)wx - 1) * srcChannels;
CALC_BICUBIC;
}
break;
case MLIB_USHORT:
{
mlib_u16 *srcData0, *srcData = mlib_ImageGetData(src);
limit_lo = MLIB_U16_MIN;
limit_hi = MLIB_U16_MAX;
srcData =
(void *)((mlib_u8 *)srcData + ((mlib_s32)wy -
1) * srcYStride);
srcData += ((mlib_s32)wx - 1) * srcChannels;
CALC_BICUBIC;
}
break;
case MLIB_INT:
{
mlib_s32 *srcData0, *srcData = mlib_ImageGetData(src);
limit_lo = MLIB_S32_MIN;
limit_hi = MLIB_S32_MAX;
srcData =
(void *)((mlib_u8 *)srcData + ((mlib_s32)wy -
1) * srcYStride);
srcData += ((mlib_s32)wx - 1) * srcChannels;
CALC_BICUBIC;
}
break;
default:
return (MLIB_FAILURE);
}
return (__mlib_ImageClear(dst, color));
}
int main()
{
init_arrays();
double annot_t_start=0, annot_t_end=0, annot_t_total=0;
int annot_i;
for (annot_i=0; annot_i<REPS; annot_i++)
{
annot_t_start = rtclock();
int t, i, j, k, l, m, n,ii,jj;
#define S1(zT0,zT1,t,j) {ey[0][j]=t;}
#define S2(zT0,zT1,zT2,t,i,j) {ey[i][j]=ey[i][j]-((double)(1))/2*(hz[i][j]-hz[i-1][j]);}
#define S3(zT0,zT1,zT2,t,i,j) {ex[i][j]=ex[i][j]-((double)(1))/2*(hz[i][j]-hz[i][j-1]);}
#define S4(zT0,zT1,zT2,t,i,j) {hz[i][j]=hz[i][j]-((double)(7))/10*(ey[1+i][j]+ex[i][1+j]-ex[i][j]-ey[i][j]);}
int c1, c2, c3, c4, c5, c6, c7;
register int lbv, ubv;
for (c1=0;c1<=floord(tmax-1,32);c1++) {
for (c2=max(ceild(32*c1-31,32),0);c2<=min(floord(tmax+ny-1,32),floord(32*c1+ny+31,32));c2++) {
for (c3=max(max(max(max(ceild(32*c2-ny-30,32),0),ceild(64*c1-32*c2-61,32)),ceild(32*c1-31,32)),ceild(32*c1-992*c2-1891,992));c3<=min(min(floord(32*c2+nx+30,32),floord(tmax+nx-1,32)),floord(32*c1+nx+31,32));c3++) {
if ((c1 <= floord(32*c3-nx,32)) && (c2 <= floord(32*c3-nx+ny,32)) && (c3 >= ceild(nx,32))) {
for (c5=max(32*c3-nx+1,32*c2);c5<=min(32*c2+31,32*c3-nx+ny);c5++) {
S4(c1,-c1+c3,-c1+c2,32*c3-nx,nx-1,-32*c3+c5+nx-1) ;
}
}
if ((c1 <= floord(32*c2-ny,32)) && (c2 >= max(ceild(32*c3-nx+ny+1,32),ceild(ny,32)))) {
for (c6=max(32*c3,32*c2-ny+1);c6<=min(32*c2+nx-ny,32*c3+31);c6++) {
S4(c1,-c1+c3,-c1+c2,32*c2-ny,-32*c2+c6+ny-1,ny-1) ;
}
}
if (c1 == c3) {
for (c4=max(max(32*c2-ny+1,0),32*c3);c4<=min(min(32*c3+30,32*c2-ny+31),tmax-1);c4++) {
for (c5=32*c2;c5<=c4+ny-1;c5++) {
S1(c1,-c1+c2,c4,-c4+c5) ;
S3(c1,0,-c1+c2,c4,0,-c4+c5) ;
for (c6=c4+1;c6<=32*c3+31;c6++) {
S2(c1,0,-c1+c2,c4,-c4+c6,-c4+c5) ;
S3(c1,0,-c1+c2,c4,-c4+c6,-c4+c5) ;
S4(c1,0,-c1+c2,c4,-c4+c6-1,-c4+c5-1) ;
}
}
for (c6=c4+1;c6<=32*c3+31;c6++) {
S4(c1,0,-c1+c2,c4,-c4+c6-1,ny-1) ;
}
}
}
if (c1 == c3) {
for (c4=max(max(0,32*c3),32*c2-ny+32);c4<=min(min(tmax-1,32*c3+30),32*c2-1);c4++) {
for (c5=32*c2;c5<=32*c2+31;c5++) {
S1(c1,-c1+c2,c4,-c4+c5) ;
S3(c1,0,-c1+c2,c4,0,-c4+c5) ;
for (c6=c4+1;c6<=32*c3+31;c6++) {
S2(c1,0,-c1+c2,c4,-c4+c6,-c4+c5) ;
S3(c1,0,-c1+c2,c4,-c4+c6,-c4+c5) ;
S4(c1,0,-c1+c2,c4,-c4+c6-1,-c4+c5-1) ;
}
}
}
}
if (c1 == c3) {
for (c4=max(max(32*c2,0),32*c3);c4<=min(min(tmax-1,32*c3+30),32*c2+30);c4++) {
S1(c1,-c1+c2,c4,0) ;
for (c6=c4+1;c6<=32*c3+31;c6++) {
S2(c1,0,-c1+c2,c4,-c4+c6,0) ;
}
for (c5=c4+1;c5<=32*c2+31;c5++) {
S1(c1,-c1+c2,c4,-c4+c5) ;
S3(c1,0,-c1+c2,c4,0,-c4+c5) ;
for (c6=c4+1;c6<=32*c3+31;c6++) {
S2(c1,0,-c1+c2,c4,-c4+c6,-c4+c5) ;
S3(c1,0,-c1+c2,c4,-c4+c6,-c4+c5) ;
S4(c1,0,-c1+c2,c4,-c4+c6-1,-c4+c5-1) ;
}
}
}
}
for (c4=max(max(max(32*c1,0),32*c2-ny+1),32*c3-nx+1);c4<=min(min(min(32*c3-nx+31,32*c2-ny+31),32*c1+31),tmax-1);c4++) {
for (c5=32*c2;c5<=c4+ny-1;c5++) {
for (c6=32*c3;c6<=c4+nx-1;c6++) {
S2(c1,-c1+c3,-c1+c2,c4,-c4+c6,-c4+c5) ;
S3(c1,-c1+c3,-c1+c2,c4,-c4+c6,-c4+c5) ;
S4(c1,-c1+c3,-c1+c2,c4,-c4+c6-1,-c4+c5-1) ;
}
S4(c1,-c1+c3,-c1+c2,c4,nx-1,-c4+c5-1) ;
}
for (c6=32*c3;c6<=c4+nx;c6++) {
S4(c1,-c1+c3,-c1+c2,c4,-c4+c6-1,ny-1) ;
}
}
for (c4=max(max(max(32*c1,0),32*c3-nx+1),32*c2-ny+32);c4<=min(min(min(tmax-1,32*c1+31),32*c2-1),32*c3-nx+31);c4++) {
for (c5=32*c2;c5<=32*c2+31;c5++) {
for (c6=32*c3;c6<=c4+nx-1;c6++) {
S2(c1,-c1+c3,-c1+c2,c4,-c4+c6,-c4+c5) ;
S3(c1,-c1+c3,-c1+c2,c4,-c4+c6,-c4+c5) ;
S4(c1,-c1+c3,-c1+c2,c4,-c4+c6-1,-c4+c5-1) ;
}
S4(c1,-c1+c3,-c1+c2,c4,nx-1,-c4+c5-1) ;
}
}
for (c4=max(max(max(32*c3-nx+32,32*c1),0),32*c2-ny+1);c4<=min(min(min(32*c2-ny+31,32*c1+31),tmax-1),32*c3-1);c4++) {
for (c5=32*c2;c5<=c4+ny-1;c5++) {
for (c6=32*c3;c6<=32*c3+31;c6++) {
S2(c1,-c1+c3,-c1+c2,c4,-c4+c6,-c4+c5) ;
S3(c1,-c1+c3,-c1+c2,c4,-c4+c6,-c4+c5) ;
S4(c1,-c1+c3,-c1+c2,c4,-c4+c6-1,-c4+c5-1) ;
}
}
for (c6=32*c3;c6<=32*c3+31;c6++) {
S4(c1,-c1+c3,-c1+c2,c4,-c4+c6-1,ny-1) ;
}
}
for (c4=max(max(max(32*c2,32*c1),0),32*c3-nx+1);c4<=min(min(min(32*c2+30,tmax-1),32*c1+31),32*c3-nx+31);c4++) {
for (c6=32*c3;c6<=c4+nx-1;c6++) {
S2(c1,-c1+c3,-c1+c2,c4,-c4+c6,0) ;
}
for (c5=c4+1;c5<=32*c2+31;c5++) {
for (c6=32*c3;c6<=c4+nx-1;c6++) {
S2(c1,-c1+c3,-c1+c2,c4,-c4+c6,-c4+c5) ;
S3(c1,-c1+c3,-c1+c2,c4,-c4+c6,-c4+c5) ;
S4(c1,-c1+c3,-c1+c2,c4,-c4+c6-1,-c4+c5-1) ;
}
S4(c1,-c1+c3,-c1+c2,c4,nx-1,-c4+c5-1) ;
}
}
for (c4=max(max(max(32*c1,0),32*c3-nx+32),32*c2-ny+32);c4<=min(min(min(32*c3-1,tmax-1),32*c1+31),32*c2-1);c4++) {
/*@ begin Loop(
transform Composite(
tile = [('c5',T1,'ii'),('c6',T2,'jj')],
permut = [PERMUTS],
unrolljam = [('c5',U1),('c6',U2)],
vector = (VEC, ['ivdep','vector always'])
)
for (c5=32*c2;c5<=32*c2+31;c5++)
for (c6=32*c3;c6<=32*c3+31;c6++)
{
S2(c1,-c1+c3,-c1+c2,c4,-c4+c6,-c4+c5) ;
S3(c1,-c1+c3,-c1+c2,c4,-c4+c6,-c4+c5) ;
S4(c1,-c1+c3,-c1+c2,c4,-c4+c6-1,-c4+c5-1) ;
}
) @*/{
for (c6=32*c3; c6<=32*c3+28; c6=c6+4) {
register int cbv_1, cbv_2;
cbv_1=32*c2;
cbv_2=32*c2+31;
#pragma ivdep
#pragma vector always
for (c5=cbv_1; c5<=cbv_2; c5=c5+1) {
S2(c1,-c1+c3,-c1+c2,c4,-c4+c6,-c4+c5);
S2(c1,-c1+c3,-c1+c2,c4,-c4+c6+1,-c4+c5);
S2(c1,-c1+c3,-c1+c2,c4,-c4+c6+2,-c4+c5);
S2(c1,-c1+c3,-c1+c2,c4,-c4+c6+3,-c4+c5);
S3(c1,-c1+c3,-c1+c2,c4,-c4+c6,-c4+c5);
S3(c1,-c1+c3,-c1+c2,c4,-c4+c6+1,-c4+c5);
S3(c1,-c1+c3,-c1+c2,c4,-c4+c6+2,-c4+c5);
S3(c1,-c1+c3,-c1+c2,c4,-c4+c6+3,-c4+c5);
S4(c1,-c1+c3,-c1+c2,c4,-c4+c6-1,-c4+c5-1);
S4(c1,-c1+c3,-c1+c2,c4,-c4+c6,-c4+c5-1);
S4(c1,-c1+c3,-c1+c2,c4,-c4+c6+1,-c4+c5-1);
S4(c1,-c1+c3,-c1+c2,c4,-c4+c6+2,-c4+c5-1);
}
}
for (; c6<=32*c3+31; c6=c6+1) {
register int cbv_3, cbv_4;
cbv_3=32*c2;
cbv_4=32*c2+31;
#pragma ivdep
#pragma vector always
for (c5=cbv_3; c5<=cbv_4; c5=c5+1) {
S2(c1,-c1+c3,-c1+c2,c4,-c4+c6,-c4+c5);
S3(c1,-c1+c3,-c1+c2,c4,-c4+c6,-c4+c5);
S4(c1,-c1+c3,-c1+c2,c4,-c4+c6-1,-c4+c5-1);
}
}
}
/*@ end @*/
}
for (c4=max(max(max(32*c2,32*c3-nx+32),32*c1),0);c4<=min(min(min(32*c3-1,32*c2+30),tmax-1),32*c1+31);c4++) {
for (c6=32*c3;c6<=32*c3+31;c6++) {
S2(c1,-c1+c3,-c1+c2,c4,-c4+c6,0) ;
}
for (c5=c4+1;c5<=32*c2+31;c5++) {
for (c6=32*c3;c6<=32*c3+31;c6++) {
S2(c1,-c1+c3,-c1+c2,c4,-c4+c6,-c4+c5) ;
S3(c1,-c1+c3,-c1+c2,c4,-c4+c6,-c4+c5) ;
S4(c1,-c1+c3,-c1+c2,c4,-c4+c6-1,-c4+c5-1) ;
}
}
}
if ((c1 == c3) && (c2 <= min(floord(32*c3-1,32),floord(tmax-32,32)))) {
S1(c1,-c1+c2,32*c2+31,0) ;
for (c6=32*c2+32;c6<=32*c3+31;c6++) {
S2(c1,0,-c1+c2,32*c2+31,-32*c2+c6-31,0) ;
}
}
if ((-c1 == -c3) && (c1 >= ceild(32*c2-31,32)) && (c1 <= min(floord(tmax-32,32),floord(32*c2-1,32)))) {
S1(c1,-c1+c2,32*c1+31,0) ;
for (c5=32*c1+32;c5<=32*c2+31;c5++) {
S1(c1,-c1+c2,32*c1+31,-32*c1+c5-31) ;
S3(c1,0,-c1+c2,32*c1+31,0,-32*c1+c5-31) ;
}
}
if ((-c1 == -c3) && (c1 <= min(floord(tmax-32,32),c2-1))) {
for (c5=32*c2;c5<=min(32*c2+31,32*c1+ny+30);c5++) {
S1(c1,-c1+c2,32*c1+31,-32*c1+c5-31) ;
S3(c1,0,-c1+c2,32*c1+31,0,-32*c1+c5-31) ;
}
}
if ((-c1 == -c2) && (-c1 == -c3) && (c1 <= floord(tmax-32,32))) {
S1(c1,0,32*c1+31,0) ;
}
if ((c1 >= c2) && (c2 <= min(c3-1,floord(tmax-32,32)))) {
for (c6=32*c3;c6<=min(32*c2+nx+30,32*c3+31);c6++) {
S2(c1,-c1+c3,-c1+c2,32*c2+31,-32*c2+c6-31,0) ;
}
}
}
}
}
annot_t_end = rtclock();
annot_t_total += annot_t_end - annot_t_start;
}
annot_t_total = annot_t_total / REPS;
printf("%f\n", annot_t_total);
return 1;
}
void test(int m)
{
/* Scattering iterators. */
int glT1, rp1, local1, local2;
/* Original iterators. */
int coordT1, coordP1, other1, other2, other3, other4, other5, other6;
if (m >= 2) {
S1(0,1,1,1) ;
S2(0,1,1,1,1,1,2,1) ;
S3(0,1,1,2,1,1,1,2) ;
S4(0,1,2,2,1,1,2,2) ;
S8(0,1) ;
}
if (m == 1) {
S1(0,1,1,1) ;
S8(0,1) ;
}
if (m >= 3) {
S5(0,1,1,1,1,1,2,1) ;
S1(1,1,2,1) ;
S2(1,1,2,1,2,1,3,1) ;
S3(1,1,2,2,2,1,2,2) ;
S4(1,1,3,2,2,1,3,2) ;
S6(0,1,1,2,1,1,1,2) ;
S7(0,1,2,2,1,1,2,2) ;
S1(1,2,1,2) ;
S2(1,2,2,2,1,2,2,2) ;
S3(1,2,2,3,1,2,1,3) ;
S4(1,2,3,3,1,2,2,3) ;
for (coordP1=1;coordP1<=2;coordP1++) {
S8(1,coordP1) ;
}
}
for (glT1=2;glT1<=m-2;glT1++) {
coordT1 = glT1-1 ;
other5 = glT1+1 ;
S5(glT1-1,1,glT1,1,glT1,1,glT1+1,1) ;
other1 = glT1+1 ;
S1(glT1,1,glT1+1,1) ;
local1 = glT1+1 ;
other1 = glT1+1 ;
other3 = glT1+1 ;
other5 = glT1+2 ;
S2(glT1,1,glT1+1,1,glT1+1,1,glT1+2,1) ;
other3 = glT1+1 ;
other5 = glT1+1 ;
S3(glT1,1,glT1+1,2,glT1+1,1,glT1+1,2) ;
other1 = glT1+2 ;
other3 = glT1+1 ;
other5 = glT1+2 ;
S4(glT1,1,glT1+2,2,glT1+1,1,glT1+2,2) ;
for (rp1=2;rp1<=glT1;rp1++) {
local1 = glT1-rp1+1 ;
coordT1 = glT1-1 ;
other3 = glT1-rp1+1 ;
other5 = glT1-rp1+2 ;
S5(glT1-1,rp1,glT1,rp1,glT1-rp1+1,rp1,glT1-rp1+2,rp1) ;
local1 = glT1-rp1+2 ;
local2 = rp1-1 ;
coordT1 = glT1-1 ;
coordP1 = rp1-1 ;
other3 = glT1-rp1+2 ;
other4 = rp1-1 ;
other5 = glT1-rp1+2 ;
S6(glT1-1,rp1-1,glT1,rp1,glT1-rp1+2,rp1-1,glT1-rp1+2,rp1) ;
other1 = glT1+1 ;
other3 = glT1-rp1+2 ;
other4 = rp1-1 ;
other5 = glT1-rp1+3 ;
S7(glT1-1,rp1-1,glT1+1,rp1,glT1-rp1+2,rp1-1,glT1-rp1+3,rp1) ;
other1 = glT1-rp1+2 ;
S1(glT1,rp1,glT1-rp1+2,rp1) ;
local1 = glT1-rp1+2 ;
other1 = glT1+1 ;
other3 = glT1-rp1+2 ;
other5 = glT1-rp1+3 ;
S2(glT1,rp1,glT1+1,rp1,glT1-rp1+2,rp1,glT1-rp1+3,rp1) ;
other2 = rp1+1 ;
other3 = glT1-rp1+2 ;
other5 = glT1-rp1+2 ;
other6 = rp1+1 ;
S3(glT1,rp1,glT1+1,rp1+1,glT1-rp1+2,rp1,glT1-rp1+2,rp1+1) ;
other1 = glT1+2 ;
other2 = rp1+1 ;
other3 = glT1-rp1+2 ;
other5 = glT1-rp1+3 ;
other6 = rp1+1 ;
S4(glT1,rp1,glT1+2,rp1+1,glT1-rp1+2,rp1,glT1-rp1+3,rp1+1) ;
}
rp1 = glT1+1 ;
coordT1 = glT1-1 ;
other2 = glT1+1 ;
other6 = glT1+1 ;
S6(glT1-1,glT1,glT1,glT1+1,1,glT1,1,glT1+1) ;
other1 = glT1+1 ;
other2 = glT1+1 ;
other6 = glT1+1 ;
S7(glT1-1,glT1,glT1+1,glT1+1,1,glT1,2,glT1+1) ;
coordP1 = glT1+1 ;
other2 = glT1+1 ;
S1(glT1,glT1+1,1,glT1+1) ;
local2 = glT1+1 ;
coordP1 = glT1+1 ;
other1 = glT1+1 ;
other2 = glT1+1 ;
other4 = glT1+1 ;
other6 = glT1+1 ;
S2(glT1,glT1+1,glT1+1,glT1+1,1,glT1+1,2,glT1+1) ;
other2 = glT1+2 ;
other4 = glT1+1 ;
other6 = glT1+2 ;
S3(glT1,glT1+1,glT1+1,glT1+2,1,glT1+1,1,glT1+2) ;
other1 = glT1+2 ;
other2 = glT1+2 ;
other4 = glT1+1 ;
other6 = glT1+2 ;
S4(glT1,glT1+1,glT1+2,glT1+2,1,glT1+1,2,glT1+2) ;
for (coordP1=1;coordP1<=glT1+1;coordP1++) {
S8(glT1,coordP1) ;
}
}
if (m >= 3) {
glT1 = m-1 ;
local1 = m-1 ;
coordT1 = m-2 ;
other1 = m-1 ;
other3 = m-1 ;
S5(m-2,1,m-1,1,m-1,1,m,1) ;
coordT1 = m-1 ;
S1(m-1,1,m,1) ;
coordT1 = m-1 ;
S3(m-1,1,m,2,m,1,m,2) ;
for (rp1=2;rp1<=m-1;rp1++) {
local1 = -rp1+m ;
coordT1 = m-2 ;
other1 = m-1 ;
other3 = -rp1+m ;
other5 = -rp1+m+1 ;
S5(m-2,rp1,m-1,rp1,-rp1+m,rp1,-rp1+m+1,rp1) ;
local1 = -rp1+m+1 ;
local2 = rp1-1 ;
coordT1 = m-2 ;
coordP1 = rp1-1 ;
other1 = m-1 ;
other3 = -rp1+m+1 ;
other4 = rp1-1 ;
other5 = -rp1+m+1 ;
S6(m-2,rp1-1,m-1,rp1,-rp1+m+1,rp1-1,-rp1+m+1,rp1) ;
other3 = -rp1+m+1 ;
other4 = rp1-1 ;
other5 = -rp1+m+2 ;
S7(m-2,rp1-1,m,rp1,-rp1+m+1,rp1-1,-rp1+m+2,rp1) ;
coordT1 = m-1 ;
other1 = -rp1+m+1 ;
S1(m-1,rp1,-rp1+m+1,rp1) ;
local1 = -rp1+m+1 ;
coordT1 = m-1 ;
other3 = -rp1+m+1 ;
other5 = -rp1+m+2 ;
S2(m-1,rp1,m,rp1,-rp1+m+1,rp1,-rp1+m+2,rp1) ;
other2 = rp1+1 ;
other3 = -rp1+m+1 ;
other5 = -rp1+m+1 ;
other6 = rp1+1 ;
S3(m-1,rp1,m,rp1+1,-rp1+m+1,rp1,-rp1+m+1,rp1+1) ;
other1 = m+1 ;
other2 = rp1+1 ;
other3 = -rp1+m+1 ;
other5 = -rp1+m+2 ;
other6 = rp1+1 ;
S4(m-1,rp1,m+1,rp1+1,-rp1+m+1,rp1,-rp1+m+2,rp1+1) ;
}
local2 = m-1 ;
coordT1 = m-2 ;
coordP1 = m-1 ;
other1 = m-1 ;
other4 = m-1 ;
S6(m-2,m-1,m-1,m,1,m-1,1,m) ;
other4 = m-1 ;
S7(m-2,m-1,m,m,1,m-1,2,m) ;
coordT1 = m-1 ;
S1(m-1,m,1,m) ;
coordT1 = m-1 ;
S2(m-1,m,m,m,1,m,2,m) ;
coordT1 = m-1 ;
for (coordP1=1;coordP1<=m;coordP1++) {
S8(m-1,coordP1) ;
}
}
for (glT1=m;glT1<=2*m-4;glT1++) {
rp1 = glT1-m+2 ;
local1 = m-1 ;
local2 = glT1-m+2 ;
coordT1 = glT1-1 ;
coordP1 = glT1-m+2 ;
other2 = glT1-m+2 ;
other3 = m-1 ;
other4 = glT1-m+2 ;
other6 = glT1-m+2 ;
S5(glT1-1,glT1-m+2,glT1,glT1-m+2,m-1,glT1-m+2,m,glT1-m+2) ;
local2 = glT1-m+1 ;
coordT1 = glT1-1 ;
coordP1 = glT1-m+1 ;
other2 = glT1-m+2 ;
other4 = glT1-m+1 ;
other6 = glT1-m+2 ;
S6(glT1-1,glT1-m+1,glT1,glT1-m+2,m,glT1-m+1,m,glT1-m+2) ;
coordP1 = glT1-m+2 ;
other2 = glT1-m+2 ;
S1(glT1,glT1-m+2,m,glT1-m+2) ;
local2 = glT1-m+2 ;
coordP1 = glT1-m+2 ;
other1 = glT1+1 ;
other2 = glT1-m+3 ;
other4 = glT1-m+2 ;
other6 = glT1-m+3 ;
S3(glT1,glT1-m+2,glT1+1,glT1-m+3,m,glT1-m+2,m,glT1-m+3) ;
for (rp1=glT1-m+3;rp1<=m-1;rp1++) {
local1 = glT1-rp1+1 ;
coordT1 = glT1-1 ;
other3 = glT1-rp1+1 ;
other5 = glT1-rp1+2 ;
S5(glT1-1,rp1,glT1,rp1,glT1-rp1+1,rp1,glT1-rp1+2,rp1) ;
local1 = glT1-rp1+2 ;
local2 = rp1-1 ;
coordT1 = glT1-1 ;
coordP1 = rp1-1 ;
other3 = glT1-rp1+2 ;
other4 = rp1-1 ;
other5 = glT1-rp1+2 ;
S6(glT1-1,rp1-1,glT1,rp1,glT1-rp1+2,rp1-1,glT1-rp1+2,rp1) ;
other1 = glT1+1 ;
other3 = glT1-rp1+2 ;
other4 = rp1-1 ;
other5 = glT1-rp1+3 ;
S7(glT1-1,rp1-1,glT1+1,rp1,glT1-rp1+2,rp1-1,glT1-rp1+3,rp1) ;
other1 = glT1-rp1+2 ;
S1(glT1,rp1,glT1-rp1+2,rp1) ;
local1 = glT1-rp1+2 ;
other1 = glT1+1 ;
other3 = glT1-rp1+2 ;
other5 = glT1-rp1+3 ;
S2(glT1,rp1,glT1+1,rp1,glT1-rp1+2,rp1,glT1-rp1+3,rp1) ;
other2 = rp1+1 ;
other3 = glT1-rp1+2 ;
other5 = glT1-rp1+2 ;
other6 = rp1+1 ;
S3(glT1,rp1,glT1+1,rp1+1,glT1-rp1+2,rp1,glT1-rp1+2,rp1+1) ;
other1 = glT1+2 ;
other2 = rp1+1 ;
other3 = glT1-rp1+2 ;
other5 = glT1-rp1+3 ;
other6 = rp1+1 ;
S4(glT1,rp1,glT1+2,rp1+1,glT1-rp1+2,rp1,glT1-rp1+3,rp1+1) ;
}
local1 = glT1-m+1 ;
coordT1 = glT1-1 ;
other3 = glT1-m+1 ;
other5 = glT1-m+2 ;
S5(glT1-1,m,glT1,m,glT1-m+1,m,glT1-m+2,m) ;
local1 = glT1-m+2 ;
local2 = m-1 ;
coordT1 = glT1-1 ;
coordP1 = m-1 ;
other3 = glT1-m+2 ;
other4 = m-1 ;
other5 = glT1-m+2 ;
S6(glT1-1,m-1,glT1,m,glT1-m+2,m-1,glT1-m+2,m) ;
other1 = glT1+1 ;
other3 = glT1-m+2 ;
other4 = m-1 ;
other5 = glT1-m+3 ;
S7(glT1-1,m-1,glT1+1,m,glT1-m+2,m-1,glT1-m+3,m) ;
other1 = glT1-m+2 ;
S1(glT1,m,glT1-m+2,m) ;
local1 = glT1-m+2 ;
other1 = glT1+1 ;
other3 = glT1-m+2 ;
other5 = glT1-m+3 ;
S2(glT1,m,glT1+1,m,glT1-m+2,m,glT1-m+3,m) ;
for (coordP1=glT1-m+2;coordP1<=m;coordP1++) {
S8(glT1,coordP1) ;
}
}
if (m >= 3) {
glT1 = 2*m-3 ;
rp1 = m-1 ;
local1 = m-1 ;
local2 = m-1 ;
coordT1 = 2*m-4 ;
coordP1 = m-1 ;
other1 = 2*m-3 ;
other2 = m-1 ;
other3 = m-1 ;
other4 = m-1 ;
other6 = m-1 ;
S5(2*m-4,m-1,2*m-3,m-1,m-1,m-1,m,m-1) ;
local2 = m-2 ;
coordT1 = 2*m-4 ;
coordP1 = m-2 ;
other1 = 2*m-3 ;
other2 = m-1 ;
other4 = m-2 ;
other6 = m-1 ;
S6(2*m-4,m-2,2*m-3,m-1,m,m-2,m,m-1) ;
coordT1 = 2*m-3 ;
coordP1 = m-1 ;
other2 = m-1 ;
S1(2*m-3,m-1,m,m-1) ;
local2 = m-1 ;
coordT1 = 2*m-3 ;
coordP1 = m-1 ;
other1 = 2*m-2 ;
other4 = m-1 ;
S3(2*m-3,m-1,2*m-2,m,m,m-1,m,m) ;
local1 = m-2 ;
coordT1 = 2*m-4 ;
other1 = 2*m-3 ;
other3 = m-2 ;
other5 = m-1 ;
S5(2*m-4,m,2*m-3,m,m-2,m,m-1,m) ;
local1 = m-1 ;
local2 = m-1 ;
coordT1 = 2*m-4 ;
coordP1 = m-1 ;
other1 = 2*m-3 ;
other3 = m-1 ;
other4 = m-1 ;
other5 = m-1 ;
S6(2*m-4,m-1,2*m-3,m,m-1,m-1,m-1,m) ;
other1 = 2*m-2 ;
other3 = m-1 ;
other4 = m-1 ;
S7(2*m-4,m-1,2*m-2,m,m-1,m-1,m,m) ;
coordT1 = 2*m-3 ;
other1 = m-1 ;
S1(2*m-3,m,m-1,m) ;
local1 = m-1 ;
coordT1 = 2*m-3 ;
other1 = 2*m-2 ;
other3 = m-1 ;
S2(2*m-3,m,2*m-2,m,m-1,m,m,m) ;
coordT1 = 2*m-3 ;
for (coordP1=m-1;coordP1<=m;coordP1++) {
S8(2*m-3,coordP1) ;
}
}
if (m == 2) {
S5(0,1,1,1,1,1,2,1) ;
S1(1,1,2,1) ;
S3(1,1,2,2,2,1,2,2) ;
S6(0,1,1,2,1,1,1,2) ;
S7(0,1,2,2,1,1,2,2) ;
S1(1,2,1,2) ;
S2(1,2,2,2,1,2,2,2) ;
for (coordP1=1;coordP1<=2;coordP1++) {
S8(1,coordP1) ;
}
}
if (m >= 2) {
glT1 = 2*m-2 ;
local1 = m-1 ;
coordT1 = 2*m-3 ;
other1 = 2*m-2 ;
other3 = m-1 ;
S5(2*m-3,m,2*m-2,m,m-1,m,m,m) ;
local2 = m-1 ;
coordT1 = 2*m-3 ;
coordP1 = m-1 ;
other1 = 2*m-2 ;
other4 = m-1 ;
S6(2*m-3,m-1,2*m-2,m,m,m-1,m,m) ;
coordT1 = 2*m-2 ;
S1(2*m-2,m,m,m) ;
coordT1 = 2*m-2 ;
S8(2*m-2,m) ;
}
}
void test(int M, int N)
{
/* Scattering iterators. */
int c2, c4, c6;
/* Original iterators. */
int i, j, k;
if ((M <= -1) && (N >= 1)) {
S1(0) ;
}
if ((M >= 0) && (N >= 1)) {
S1(0) ;
}
if ((M >= 1) && (N >= 2)) {
for (c4=0;c4<=M-1;c4++) {
S2(0,c4) ;
}
S3(0) ;
for (c4=0;c4<=M-1;c4++) {
S4(0,c4) ;
}
S10(0) ;
S1(1) ;
S5(0) ;
}
if ((M <= 0) && (N >= 2)) {
S3(0) ;
S10(0) ;
S1(1) ;
S5(0) ;
}
if ((M >= 1) && (N == 1)) {
for (c4=0;c4<=M-1;c4++) {
S2(0,c4) ;
}
S3(0) ;
for (c4=0;c4<=M-1;c4++) {
S4(0,c4) ;
}
S10(0) ;
S5(0) ;
}
if ((M <= 0) && (N == 1)) {
S3(0) ;
S10(0) ;
S5(0) ;
}
for (c2=2;c2<=min(N-1,M);c2++) {
for (c4=c2-1;c4<=N-1;c4++) {
i = c2-2 ;
S6(c2-2,c4) ;
for (c6=c2-2;c6<=M-1;c6++) {
i = c2-2 ;
S7(c2-2,c4,c6) ;
}
i = c2-2 ;
S8(c2-2,c4) ;
for (c6=c2-2;c6<=M-1;c6++) {
i = c2-2 ;
S9(c2-2,c4,c6) ;
}
}
for (c4=c2-1;c4<=M-1;c4++) {
i = c2-1 ;
S2(c2-1,c4) ;
}
i = c2-1 ;
S3(c2-1) ;
for (c4=c2-1;c4<=M-1;c4++) {
i = c2-1 ;
S4(c2-1,c4) ;
}
i = c2-1 ;
S10(c2-1) ;
S1(c2) ;
i = c2-1 ;
S5(c2-1) ;
}
if ((M >= 1) && (M <= N-2)) {
c2 = M+1 ;
for (c4=M;c4<=N-1;c4++) {
i = M-1 ;
S6(M-1,c4) ;
c6 = M-1 ;
i = M-1 ;
k = M-1 ;
S7(M-1,c4,M-1) ;
i = M-1 ;
S8(M-1,c4) ;
c6 = M-1 ;
i = M-1 ;
k = M-1 ;
S9(M-1,c4,M-1) ;
}
S3(M) ;
S10(M) ;
i = M+1 ;
S1(M+1) ;
S5(M) ;
}
if ((M >= N) && (N >= 2)) {
c4 = N-1 ;
i = N-2 ;
j = N-1 ;
S6(N-2,N-1) ;
for (c6=N-2;c6<=M-1;c6++) {
i = N-2 ;
j = N-1 ;
S7(N-2,N-1,c6) ;
}
i = N-2 ;
j = N-1 ;
S8(N-2,N-1) ;
for (c6=N-2;c6<=M-1;c6++) {
i = N-2 ;
j = N-1 ;
S9(N-2,N-1,c6) ;
}
for (c4=N-1;c4<=M-1;c4++) {
i = N-1 ;
S2(N-1,c4) ;
}
i = N-1 ;
S3(N-1) ;
for (c4=N-1;c4<=M-1;c4++) {
i = N-1 ;
S4(N-1,c4) ;
}
i = N-1 ;
S10(N-1) ;
i = N-1 ;
S5(N-1) ;
}
if ((M == N-1) && (N >= 2)) {
c4 = N-1 ;
i = N-2 ;
j = N-1 ;
S6(N-2,N-1) ;
c6 = N-2 ;
i = N-2 ;
j = N-1 ;
k = N-2 ;
S7(N-2,N-1,N-2) ;
i = N-2 ;
j = N-1 ;
S8(N-2,N-1) ;
c6 = N-2 ;
i = N-2 ;
j = N-1 ;
k = N-2 ;
S9(N-2,N-1,N-2) ;
i = N-1 ;
S3(N-1) ;
i = N-1 ;
S10(N-1) ;
i = N-1 ;
S5(N-1) ;
}
for (c2=max(M+2,2);c2<=N-1;c2++) {
for (c4=c2-1;c4<=N-1;c4++) {
i = c2-2 ;
S6(c2-2,c4) ;
i = c2-2 ;
S8(c2-2,c4) ;
}
i = c2-1 ;
S3(c2-1) ;
i = c2-1 ;
S10(c2-1) ;
S1(c2) ;
i = c2-1 ;
S5(c2-1) ;
}
if ((M <= N-2) && (N >= 2)) {
c4 = N-1 ;
i = N-2 ;
j = N-1 ;
S6(N-2,N-1) ;
i = N-2 ;
j = N-1 ;
S8(N-2,N-1) ;
i = N-1 ;
S3(N-1) ;
i = N-1 ;
S10(N-1) ;
i = N-1 ;
S5(N-1) ;
}
}
SolidesP ConstruireNormale (FacesP Face)
// Construit un solide symbolisant la normale à la face.
// Le solide est placé sur le barycentre de la face et peut donc
// être hors de la face.
// Sa longueur est égale à 5% de la dimension du solide à laquelle la
// face appartient s'il existe. Sinon, c'est 10 % de la dimension de la face.
{
SolidesP Sol = Face.Solide () ;
double HauteurTot ;
Englobants3D EnglobantFace = Face.Englobant () ;
if (Sol.EstInitialise ()) {
Englobants3D E = Sol.Englobant () ;
Vecteurs3D V (E.BasGauche (),E.HautDroit ()) ;
HauteurTot = 0.05*V.Norme () ; ;
}
else {
Vecteurs3D V (EnglobantFace.BasGauche (),EnglobantFace.HautDroit ()) ;
HauteurTot = 0.1*V.Norme () ; ;
}
double LargeurPied = HauteurTot / 24,
LargeurTete = HauteurTot / 4,
HauteurPied = (7./8.)*HauteurTot ;
// Construction d'un repère centré sur le "barycentre" de la face, dont
// le (xOy) correspond au plan de la face et dont le z est la normale à
// la face.
Points3D Origine = 0.5*(EnglobantFace.BasGauche ()+EnglobantFace.HautDroit ()) ;
Vecteurs3D K = Face.VecteurNormal ().VecteurNorme (),
U (Face.ContourExterieur ().IemeAreteOrientee (0).Origine ().Point3D (),
Face.ContourExterieur ().IemeAreteOrientee (0).Extremite ().Point3D ()),
I = (K & U).VecteurNorme (),
J = (K & I).VecteurNorme () ;
SommetsP S1 (Origine-LargeurPied/2*I - LargeurPied/2*J) ;
SommetsP S2 (Origine-LargeurPied/2*I + LargeurPied/2*J) ;
SommetsP S3 (Origine+LargeurPied/2*I + LargeurPied/2*J) ;
SommetsP S4 (Origine+LargeurPied/2*I - LargeurPied/2*J) ;
SommetsP S5 (Origine-LargeurPied/2*I - LargeurPied/2*J + HauteurPied*K) ;
SommetsP S6 (Origine-LargeurPied/2*I + LargeurPied/2*J + HauteurPied*K) ;
SommetsP S7 (Origine+LargeurPied/2*I + LargeurPied/2*J + HauteurPied*K) ;
SommetsP S8 (Origine+LargeurPied/2*I - LargeurPied/2*J + HauteurPied*K) ;
SommetsP S9 (Origine-LargeurTete/2*I - LargeurTete/2*J + HauteurPied*K) ;
SommetsP S10 (Origine-LargeurTete/2*I + LargeurTete/2*J + HauteurPied*K) ;
SommetsP S11 (Origine+LargeurTete/2*I + LargeurTete/2*J + HauteurPied*K) ;
SommetsP S12 (Origine+LargeurTete/2*I - LargeurTete/2*J + HauteurPied*K) ;
SommetsP S13 (Origine+HauteurTot*K) ;
AretesP A1 (S1,S2) ;
AretesP A2 (S2,S3) ;
AretesP A3 (S3,S4) ;
AretesP A4 (S4,S1) ;
AretesP A5 (S5,S6) ;
AretesP A6 (S6,S7) ;
AretesP A7 (S7,S8) ;
AretesP A8 (S8,S5) ;
AretesP A9 (S9,S10) ;
AretesP A10 (S10,S11) ;
AretesP A11 (S11,S12) ;
AretesP A12 (S12,S9) ;
AretesP A13 (S1,S5) ;
AretesP A14 (S2,S6) ;
AretesP A15 (S3,S7) ;
AretesP A16 (S4,S8) ;
AretesP A17 (S9,S13) ;
AretesP A18 (S10,S13) ;
AretesP A19 (S11,S13) ;
AretesP A20 (S12,S13) ;
Listes <AretesP> L1 ;
L1.InsertionEnQueue (A1) ;
L1.InsertionEnQueue (A2) ;
L1.InsertionEnQueue (A3) ;
L1.InsertionEnQueue (A4) ;
Listes <AretesP> L2 ;
L2.InsertionEnQueue (A1) ;
L2.InsertionEnQueue (A13) ;
L2.InsertionEnQueue (A5) ;
L2.InsertionEnQueue (A14) ;
Listes <AretesP> L3 ;
L3.InsertionEnQueue (A2) ;
L3.InsertionEnQueue (A14) ;
L3.InsertionEnQueue (A6) ;
L3.InsertionEnQueue (A15) ;
Listes <AretesP> L4 ;
L4.InsertionEnQueue (A3) ;
L4.InsertionEnQueue (A15) ;
L4.InsertionEnQueue (A7) ;
L4.InsertionEnQueue (A16) ;
Listes <AretesP> L5 ;
L5.InsertionEnQueue (A4) ;
L5.InsertionEnQueue (A16) ;
L5.InsertionEnQueue (A8) ;
L5.InsertionEnQueue (A13) ;
Listes <AretesP> L6 ;
L6.InsertionEnQueue (A9) ;
L6.InsertionEnQueue (A10) ;
L6.InsertionEnQueue (A11) ;
L6.InsertionEnQueue (A12) ;
Listes <AretesP> L7 ;
L7.InsertionEnQueue (A8) ;
L7.InsertionEnQueue (A7) ;
L7.InsertionEnQueue (A6) ;
L7.InsertionEnQueue (A5) ;
Listes <AretesP> L8 ;
L8.InsertionEnQueue (A9) ;
L8.InsertionEnQueue (A17) ;
L8.InsertionEnQueue (A18) ;
Listes <AretesP> L9 ;
L9.InsertionEnQueue (A10) ;
L9.InsertionEnQueue (A18) ;
L9.InsertionEnQueue (A19) ;
Listes <AretesP> L10 ;
L10.InsertionEnQueue (A11) ;
L10.InsertionEnQueue (A19) ;
L10.InsertionEnQueue (A20) ;
Listes <AretesP> L11 ;
L11.InsertionEnQueue (A12) ;
L11.InsertionEnQueue (A20) ;
L11.InsertionEnQueue (A17) ;
Listes <FacesP> ListeFaces ;
AttributsFaces *PAF = new AttributsFaces (PMateriauRouge) ;
FacesP F1 (ContoursP (L1),PAF) ;
ListeFaces.InsertionEnQueue (F1) ;
ListeFaces.InsertionEnQueue (FacesP (ContoursP (L2),PAF)) ;
ListeFaces.InsertionEnQueue (FacesP (ContoursP (L3),PAF)) ;
ListeFaces.InsertionEnQueue (FacesP (ContoursP (L4),PAF)) ;
ListeFaces.InsertionEnQueue (FacesP (ContoursP (L5),PAF)) ;
ContoursP C (L6) ;
FacesP F (C,PAF) ;
F.AjouterContourInterieur (ContoursP (L7)) ;
ListeFaces.InsertionEnQueue (F) ;
ListeFaces.InsertionEnQueue (FacesP (ContoursP (L8),PAF)) ;
ListeFaces.InsertionEnQueue (FacesP (ContoursP (L9),PAF)) ;
ListeFaces.InsertionEnQueue (FacesP (ContoursP (L10),PAF)) ;
ListeFaces.InsertionEnQueue (FacesP (ContoursP (L11),PAF)) ;
return SolidesP (ListeFaces) ;
}
#include <math.h>
#include <stdlib.h>
#include <string.h>
#include "SDL.h"
#define X2(a) a a
#define X4(a) a a a a
#define S1(a,b,c) #a".."#b".."#c"."
#define S14(a,b,c) X4(S1(a,b,c))
#define S2(a) #a"."#a"....."
#define S24(a) X4(S2(a))
#define S4(a) #a#a#a#a
#define S3(a,b,c) S1(a,b,c)S4(..)
#define SE X4(X4(S4(..)))
char l[]=SE SE X2(S3(J,H,M)S3(J,H,E)S3(F,E,A)S3(F,E,J)S3(H,E,O)S3(H,E,C)S3(H,F,
x)S3(H,F,L)),b[]=SE X2(S4(j.jv.j.v)S4(f.fr.f.r)S4(e.eq.e.q)S4(h.ht.h.t))SE,*r[3
]={S14(v,v,q)S14(r,r,m)S14(q,q,l)S14(t,t,o),S24(J)S24(F)S24(E)S24(H),S24(M)S24(
J)S24(H)S24(L)};
#define B int
#define C double
#define S static
#define I(a,b,c,d,f,g) a=(f-d)/10.,b=1e-2*(d*(28-g)-f),c=1e-2*(d*f-8*g/3);\
d+=a,f+=b,g+=c;
S C T;typedef float A;S B D,R,U,p=0;S A F[5][0100000]={{0},{0}};
void AA(void*u,Uint8*_,B L){u=u;while(L>0){B M=p&037777,s=p>>12,u=(s%R)[
l],J=(s%U)[b],w=0,a=0,n;A v,q,m,E=(0x2000-(p&017777))/8192e0f;v=q=0;
#define EF_(x) F[w][1638##x+M
#define EF(l,s,ms) ((s*ms+EF_(4)-l]*(1-ms))/2.f+EF_(3)]/2.f)
void test(int M, int N, int O, int P, int Q, int R)
{
/* Scattering iterators. */
int p1, p3, p5;
/* Original iterators. */
int i, j, k;
if (M == 1) {
S1() ;
S2() ;
S3() ;
S4() ;
S5() ;
S6() ;
S7() ;
S8() ;
S9() ;
S10() ;
S11() ;
S12() ;
S13() ;
S14() ;
S15() ;
S16() ;
S17() ;
S18() ;
S19() ;
S20() ;
S21() ;
S22() ;
S23() ;
S24() ;
S25() ;
S26() ;
S27() ;
}
if (M == 1) {
for (p1=1;p1<=N;p1++) {
for (p3=1;p3<=N;p3++) {
S28(p1,p3) ;
S29(p1,p3) ;
S30(p1,p3) ;
}
S31(p1) ;
}
}
if (M == 1) {
S32() ;
S33() ;
S34() ;
}
if ((M == 1) && (O <= 1)) {
S35() ;
}
if (M == 1) {
S36() ;
S37() ;
}
if ((M == 1) && (N >= 1) && (Q >= 1) && (R >= 1)) {
for (p1=2;p1<=P;p1++) {
S38(p1) ;
S39(p1) ;
for (p3=1;p3<=Q;p3++) {
for (p5=1;p5<=R;p5++) {
S40(p1,p3,p5) ;
S41(p1,p3,p5) ;
S42(p1,p3,p5) ;
S43(p1,p3,p5) ;
}
}
for (p3=1;p3<=Q;p3++) {
S44(p1,p3) ;
S45(p1,p3) ;
S46(p1,p3) ;
S47(p1,p3) ;
}
for (p3=1;p3<=R;p3++) {
S48(p1,p3) ;
S49(p1,p3) ;
S50(p1,p3) ;
S51(p1,p3) ;
}
S52(p1) ;
S53(p1) ;
S54(p1) ;
S55(p1) ;
S56(p1) ;
S57(p1) ;
S58(p1) ;
for (p3=1;p3<=Q;p3++) {
for (p5=1;p5<=R;p5++) {
S59(p1,p3,p5) ;
S60(p1,p3,p5) ;
S61(p1,p3,p5) ;
}
}
for (p3=1;p3<=Q;p3++) {
S62(p1,p3) ;
S63(p1,p3) ;
S64(p1,p3) ;
}
for (p3=1;p3<=R;p3++) {
S65(p1,p3) ;
S66(p1,p3) ;
S67(p1,p3) ;
}
S68(p1) ;
S69(p1) ;
S70(p1) ;
S71(p1) ;
S72(p1) ;
S73(p1) ;
S74(p1) ;
S75(p1) ;
S76(p1) ;
S77(p1) ;
S78(p1) ;
S79(p1) ;
S80(p1) ;
S81(p1) ;
S82(p1) ;
S83(p1) ;
S84(p1) ;
S85(p1) ;
S86(p1) ;
S87(p1) ;
S88(p1) ;
S89(p1) ;
S90(p1) ;
S91(p1) ;
S92(p1) ;
S93(p1) ;
S94(p1) ;
for (p3=1;p3<=N;p3++) {
for (p5=1;p5<=N;p5++) {
S95(p1,p3,p5) ;
S96(p1,p3,p5) ;
S97(p1,p3,p5) ;
}
S98(p1,p3) ;
}
S99(p1) ;
S100(p1) ;
S101(p1) ;
for (p3=1;p3<=Q;p3++) {
for (p5=1;p5<=R;p5++) {
S102(p1,p3,p5) ;
S103(p1,p3,p5) ;
S104(p1,p3,p5) ;
S105(p1,p3,p5) ;
S106(p1,p3,p5) ;
S107(p1,p3,p5) ;
}
}
for (p3=1;p3<=Q;p3++) {
S108(p1,p3) ;
S109(p1,p3) ;
S110(p1,p3) ;
S111(p1,p3) ;
S112(p1,p3) ;
S113(p1,p3) ;
}
for (p3=1;p3<=R;p3++) {
S114(p1,p3) ;
S115(p1,p3) ;
S116(p1,p3) ;
S117(p1,p3) ;
S118(p1,p3) ;
S119(p1,p3) ;
}
S120(p1) ;
S121(p1) ;
S122(p1) ;
S123(p1) ;
S124(p1) ;
S125(p1) ;
}
}
if ((M == 1) && (N <= 0) && (Q >= 1) && (R >= 1)) {
for (p1=2;p1<=P;p1++) {
S38(p1) ;
S39(p1) ;
for (p3=1;p3<=Q;p3++) {
for (p5=1;p5<=R;p5++) {
S40(p1,p3,p5) ;
S41(p1,p3,p5) ;
S42(p1,p3,p5) ;
S43(p1,p3,p5) ;
}
}
for (p3=1;p3<=Q;p3++) {
S44(p1,p3) ;
S45(p1,p3) ;
S46(p1,p3) ;
S47(p1,p3) ;
}
for (p3=1;p3<=R;p3++) {
S48(p1,p3) ;
S49(p1,p3) ;
S50(p1,p3) ;
S51(p1,p3) ;
}
S52(p1) ;
S53(p1) ;
S54(p1) ;
S55(p1) ;
S56(p1) ;
S57(p1) ;
S58(p1) ;
for (p3=1;p3<=Q;p3++) {
for (p5=1;p5<=R;p5++) {
S59(p1,p3,p5) ;
S60(p1,p3,p5) ;
S61(p1,p3,p5) ;
}
}
for (p3=1;p3<=Q;p3++) {
S62(p1,p3) ;
S63(p1,p3) ;
S64(p1,p3) ;
}
for (p3=1;p3<=R;p3++) {
S65(p1,p3) ;
S66(p1,p3) ;
S67(p1,p3) ;
}
S68(p1) ;
S69(p1) ;
S70(p1) ;
S71(p1) ;
S72(p1) ;
S73(p1) ;
S74(p1) ;
S75(p1) ;
S76(p1) ;
S77(p1) ;
S78(p1) ;
S79(p1) ;
S80(p1) ;
S81(p1) ;
S82(p1) ;
S83(p1) ;
S84(p1) ;
S85(p1) ;
S86(p1) ;
S87(p1) ;
S88(p1) ;
S89(p1) ;
S90(p1) ;
S91(p1) ;
S92(p1) ;
S93(p1) ;
S94(p1) ;
S99(p1) ;
S100(p1) ;
S101(p1) ;
for (p3=1;p3<=Q;p3++) {
for (p5=1;p5<=R;p5++) {
S102(p1,p3,p5) ;
S103(p1,p3,p5) ;
S104(p1,p3,p5) ;
S105(p1,p3,p5) ;
S106(p1,p3,p5) ;
S107(p1,p3,p5) ;
}
}
for (p3=1;p3<=Q;p3++) {
S108(p1,p3) ;
S109(p1,p3) ;
S110(p1,p3) ;
S111(p1,p3) ;
S112(p1,p3) ;
S113(p1,p3) ;
}
for (p3=1;p3<=R;p3++) {
S114(p1,p3) ;
S115(p1,p3) ;
S116(p1,p3) ;
S117(p1,p3) ;
S118(p1,p3) ;
S119(p1,p3) ;
}
S120(p1) ;
S121(p1) ;
S122(p1) ;
S123(p1) ;
S124(p1) ;
S125(p1) ;
}
}
if ((M == 1) && (N >= 1) && (Q <= 0) && (R >= 1)) {
for (p1=2;p1<=P;p1++) {
S38(p1) ;
S39(p1) ;
for (p3=1;p3<=R;p3++) {
S48(p1,p3) ;
S49(p1,p3) ;
S50(p1,p3) ;
S51(p1,p3) ;
}
S52(p1) ;
S53(p1) ;
S54(p1) ;
S55(p1) ;
S56(p1) ;
S57(p1) ;
S58(p1) ;
for (p3=1;p3<=R;p3++) {
S65(p1,p3) ;
S66(p1,p3) ;
S67(p1,p3) ;
}
S68(p1) ;
S69(p1) ;
S70(p1) ;
S71(p1) ;
S72(p1) ;
S73(p1) ;
S74(p1) ;
S75(p1) ;
S76(p1) ;
S77(p1) ;
S78(p1) ;
S79(p1) ;
S80(p1) ;
S81(p1) ;
S82(p1) ;
S83(p1) ;
S84(p1) ;
S85(p1) ;
S86(p1) ;
S87(p1) ;
S88(p1) ;
S89(p1) ;
S90(p1) ;
S91(p1) ;
S92(p1) ;
S93(p1) ;
S94(p1) ;
for (p3=1;p3<=N;p3++) {
for (p5=1;p5<=N;p5++) {
S95(p1,p3,p5) ;
S96(p1,p3,p5) ;
S97(p1,p3,p5) ;
}
S98(p1,p3) ;
}
S99(p1) ;
S100(p1) ;
S101(p1) ;
for (p3=1;p3<=R;p3++) {
S114(p1,p3) ;
S115(p1,p3) ;
S116(p1,p3) ;
S117(p1,p3) ;
S118(p1,p3) ;
S119(p1,p3) ;
}
S120(p1) ;
S121(p1) ;
S122(p1) ;
S123(p1) ;
S124(p1) ;
S125(p1) ;
}
}
if ((M == 1) && (N <= 0) && (Q <= 0) && (R >= 1)) {
for (p1=2;p1<=P;p1++) {
S38(p1) ;
S39(p1) ;
for (p3=1;p3<=R;p3++) {
S48(p1,p3) ;
S49(p1,p3) ;
S50(p1,p3) ;
S51(p1,p3) ;
}
S52(p1) ;
S53(p1) ;
S54(p1) ;
S55(p1) ;
S56(p1) ;
S57(p1) ;
S58(p1) ;
for (p3=1;p3<=R;p3++) {
S65(p1,p3) ;
S66(p1,p3) ;
S67(p1,p3) ;
}
S68(p1) ;
S69(p1) ;
S70(p1) ;
S71(p1) ;
S72(p1) ;
S73(p1) ;
S74(p1) ;
S75(p1) ;
S76(p1) ;
S77(p1) ;
S78(p1) ;
S79(p1) ;
S80(p1) ;
S81(p1) ;
S82(p1) ;
S83(p1) ;
S84(p1) ;
S85(p1) ;
S86(p1) ;
S87(p1) ;
S88(p1) ;
S89(p1) ;
S90(p1) ;
S91(p1) ;
S92(p1) ;
S93(p1) ;
S94(p1) ;
S99(p1) ;
S100(p1) ;
S101(p1) ;
for (p3=1;p3<=R;p3++) {
S114(p1,p3) ;
S115(p1,p3) ;
S116(p1,p3) ;
S117(p1,p3) ;
S118(p1,p3) ;
S119(p1,p3) ;
}
S120(p1) ;
S121(p1) ;
S122(p1) ;
S123(p1) ;
S124(p1) ;
S125(p1) ;
}
}
if ((M == 1) && (N >= 1) && (Q <= 0) && (R <= 0)) {
for (p1=2;p1<=P;p1++) {
S38(p1) ;
S39(p1) ;
S52(p1) ;
S53(p1) ;
S54(p1) ;
S55(p1) ;
S56(p1) ;
S57(p1) ;
S58(p1) ;
S68(p1) ;
S69(p1) ;
S70(p1) ;
S71(p1) ;
S72(p1) ;
S73(p1) ;
S74(p1) ;
S75(p1) ;
S76(p1) ;
S77(p1) ;
S78(p1) ;
S79(p1) ;
S80(p1) ;
S81(p1) ;
S82(p1) ;
S83(p1) ;
S84(p1) ;
S85(p1) ;
S86(p1) ;
S87(p1) ;
S88(p1) ;
S89(p1) ;
S90(p1) ;
S91(p1) ;
S92(p1) ;
S93(p1) ;
S94(p1) ;
for (p3=1;p3<=N;p3++) {
for (p5=1;p5<=N;p5++) {
S95(p1,p3,p5) ;
S96(p1,p3,p5) ;
S97(p1,p3,p5) ;
}
S98(p1,p3) ;
}
S99(p1) ;
S100(p1) ;
S101(p1) ;
S120(p1) ;
S121(p1) ;
S122(p1) ;
S123(p1) ;
S124(p1) ;
S125(p1) ;
}
}
if ((M == 1) && (N <= 0) && (Q <= 0) && (R <= 0)) {
for (p1=2;p1<=P;p1++) {
S38(p1) ;
S39(p1) ;
S52(p1) ;
S53(p1) ;
S54(p1) ;
S55(p1) ;
S56(p1) ;
S57(p1) ;
S58(p1) ;
S68(p1) ;
S69(p1) ;
S70(p1) ;
S71(p1) ;
S72(p1) ;
S73(p1) ;
S74(p1) ;
S75(p1) ;
S76(p1) ;
S77(p1) ;
S78(p1) ;
S79(p1) ;
S80(p1) ;
S81(p1) ;
S82(p1) ;
S83(p1) ;
S84(p1) ;
S85(p1) ;
S86(p1) ;
S87(p1) ;
S88(p1) ;
S89(p1) ;
S90(p1) ;
S91(p1) ;
S92(p1) ;
S93(p1) ;
S94(p1) ;
S99(p1) ;
S100(p1) ;
S101(p1) ;
S120(p1) ;
S121(p1) ;
S122(p1) ;
S123(p1) ;
S124(p1) ;
S125(p1) ;
}
}
if ((M == 1) && (N >= 1) && (Q >= 1) && (R <= 0)) {
for (p1=2;p1<=P;p1++) {
S38(p1) ;
S39(p1) ;
for (p3=1;p3<=Q;p3++) {
S44(p1,p3) ;
S45(p1,p3) ;
S46(p1,p3) ;
S47(p1,p3) ;
}
S52(p1) ;
S53(p1) ;
S54(p1) ;
S55(p1) ;
S56(p1) ;
S57(p1) ;
S58(p1) ;
for (p3=1;p3<=Q;p3++) {
S62(p1,p3) ;
S63(p1,p3) ;
S64(p1,p3) ;
}
S68(p1) ;
S69(p1) ;
S70(p1) ;
S71(p1) ;
S72(p1) ;
S73(p1) ;
S74(p1) ;
S75(p1) ;
S76(p1) ;
S77(p1) ;
S78(p1) ;
S79(p1) ;
S80(p1) ;
S81(p1) ;
S82(p1) ;
S83(p1) ;
S84(p1) ;
S85(p1) ;
S86(p1) ;
S87(p1) ;
S88(p1) ;
S89(p1) ;
S90(p1) ;
S91(p1) ;
S92(p1) ;
S93(p1) ;
S94(p1) ;
for (p3=1;p3<=N;p3++) {
for (p5=1;p5<=N;p5++) {
S95(p1,p3,p5) ;
S96(p1,p3,p5) ;
S97(p1,p3,p5) ;
}
S98(p1,p3) ;
}
S99(p1) ;
S100(p1) ;
S101(p1) ;
for (p3=1;p3<=Q;p3++) {
S108(p1,p3) ;
S109(p1,p3) ;
S110(p1,p3) ;
S111(p1,p3) ;
S112(p1,p3) ;
S113(p1,p3) ;
}
S120(p1) ;
S121(p1) ;
S122(p1) ;
S123(p1) ;
S124(p1) ;
S125(p1) ;
}
}
if ((M == 1) && (N <= 0) && (Q >= 1) && (R <= 0)) {
for (p1=2;p1<=P;p1++) {
S38(p1) ;
S39(p1) ;
for (p3=1;p3<=Q;p3++) {
S44(p1,p3) ;
S45(p1,p3) ;
S46(p1,p3) ;
S47(p1,p3) ;
}
S52(p1) ;
S53(p1) ;
S54(p1) ;
S55(p1) ;
S56(p1) ;
S57(p1) ;
S58(p1) ;
for (p3=1;p3<=Q;p3++) {
S62(p1,p3) ;
S63(p1,p3) ;
S64(p1,p3) ;
}
S68(p1) ;
S69(p1) ;
S70(p1) ;
S71(p1) ;
S72(p1) ;
S73(p1) ;
S74(p1) ;
S75(p1) ;
S76(p1) ;
S77(p1) ;
S78(p1) ;
S79(p1) ;
S80(p1) ;
S81(p1) ;
S82(p1) ;
S83(p1) ;
S84(p1) ;
S85(p1) ;
S86(p1) ;
S87(p1) ;
S88(p1) ;
S89(p1) ;
S90(p1) ;
S91(p1) ;
S92(p1) ;
S93(p1) ;
S94(p1) ;
S99(p1) ;
S100(p1) ;
S101(p1) ;
for (p3=1;p3<=Q;p3++) {
S108(p1,p3) ;
S109(p1,p3) ;
S110(p1,p3) ;
S111(p1,p3) ;
S112(p1,p3) ;
S113(p1,p3) ;
}
S120(p1) ;
S121(p1) ;
S122(p1) ;
S123(p1) ;
S124(p1) ;
S125(p1) ;
}
}
}
void _stdcall serpent256_set_key(const unsigned char *key, serpent256_key *skey)
{
u32 *k = skey->expkey;
u32 r0,r1,r2,r3,r4;
/* Copy key, add padding */
memcpy(k, key, SERPENT_KEY_SIZE);
/* Expand key using polynomial */
r0 = k[3]; r1 = k[4]; r2 = k[5];
r3 = k[6]; r4 = k[7];
keyiter(k[0],r0,r4,r2,0,0);
keyiter(k[1],r1,r0,r3,1,1);
keyiter(k[2],r2,r1,r4,2,2);
keyiter(k[3],r3,r2,r0,3,3);
keyiter(k[4],r4,r3,r1,4,4);
keyiter(k[5],r0,r4,r2,5,5);
keyiter(k[6],r1,r0,r3,6,6);
keyiter(k[7],r2,r1,r4,7,7);
keyiter(k[ 0],r3,r2,r0, 8, 8); keyiter(k[ 1],r4,r3,r1, 9, 9);
keyiter(k[ 2],r0,r4,r2, 10, 10); keyiter(k[ 3],r1,r0,r3, 11, 11);
keyiter(k[ 4],r2,r1,r4, 12, 12); keyiter(k[ 5],r3,r2,r0, 13, 13);
keyiter(k[ 6],r4,r3,r1, 14, 14); keyiter(k[ 7],r0,r4,r2, 15, 15);
keyiter(k[ 8],r1,r0,r3, 16, 16); keyiter(k[ 9],r2,r1,r4, 17, 17);
keyiter(k[ 10],r3,r2,r0, 18, 18); keyiter(k[ 11],r4,r3,r1, 19, 19);
keyiter(k[ 12],r0,r4,r2, 20, 20); keyiter(k[ 13],r1,r0,r3, 21, 21);
keyiter(k[ 14],r2,r1,r4, 22, 22); keyiter(k[ 15],r3,r2,r0, 23, 23);
keyiter(k[ 16],r4,r3,r1, 24, 24); keyiter(k[ 17],r0,r4,r2, 25, 25);
keyiter(k[ 18],r1,r0,r3, 26, 26); keyiter(k[ 19],r2,r1,r4, 27, 27);
keyiter(k[ 20],r3,r2,r0, 28, 28); keyiter(k[ 21],r4,r3,r1, 29, 29);
keyiter(k[ 22],r0,r4,r2, 30, 30); keyiter(k[ 23],r1,r0,r3, 31, 31);
k += 50;
keyiter(k[-26],r2,r1,r4, 32,-18); keyiter(k[-25],r3,r2,r0, 33,-17);
keyiter(k[-24],r4,r3,r1, 34,-16); keyiter(k[-23],r0,r4,r2, 35,-15);
keyiter(k[-22],r1,r0,r3, 36,-14); keyiter(k[-21],r2,r1,r4, 37,-13);
keyiter(k[-20],r3,r2,r0, 38,-12); keyiter(k[-19],r4,r3,r1, 39,-11);
keyiter(k[-18],r0,r4,r2, 40,-10); keyiter(k[-17],r1,r0,r3, 41, -9);
keyiter(k[-16],r2,r1,r4, 42, -8); keyiter(k[-15],r3,r2,r0, 43, -7);
keyiter(k[-14],r4,r3,r1, 44, -6); keyiter(k[-13],r0,r4,r2, 45, -5);
keyiter(k[-12],r1,r0,r3, 46, -4); keyiter(k[-11],r2,r1,r4, 47, -3);
keyiter(k[-10],r3,r2,r0, 48, -2); keyiter(k[ -9],r4,r3,r1, 49, -1);
keyiter(k[ -8],r0,r4,r2, 50, 0); keyiter(k[ -7],r1,r0,r3, 51, 1);
keyiter(k[ -6],r2,r1,r4, 52, 2); keyiter(k[ -5],r3,r2,r0, 53, 3);
keyiter(k[ -4],r4,r3,r1, 54, 4); keyiter(k[ -3],r0,r4,r2, 55, 5);
keyiter(k[ -2],r1,r0,r3, 56, 6); keyiter(k[ -1],r2,r1,r4, 57, 7);
keyiter(k[ 0],r3,r2,r0, 58, 8); keyiter(k[ 1],r4,r3,r1, 59, 9);
keyiter(k[ 2],r0,r4,r2, 60, 10); keyiter(k[ 3],r1,r0,r3, 61, 11);
keyiter(k[ 4],r2,r1,r4, 62, 12); keyiter(k[ 5],r3,r2,r0, 63, 13);
keyiter(k[ 6],r4,r3,r1, 64, 14); keyiter(k[ 7],r0,r4,r2, 65, 15);
keyiter(k[ 8],r1,r0,r3, 66, 16); keyiter(k[ 9],r2,r1,r4, 67, 17);
keyiter(k[ 10],r3,r2,r0, 68, 18); keyiter(k[ 11],r4,r3,r1, 69, 19);
keyiter(k[ 12],r0,r4,r2, 70, 20); keyiter(k[ 13],r1,r0,r3, 71, 21);
keyiter(k[ 14],r2,r1,r4, 72, 22); keyiter(k[ 15],r3,r2,r0, 73, 23);
keyiter(k[ 16],r4,r3,r1, 74, 24); keyiter(k[ 17],r0,r4,r2, 75, 25);
keyiter(k[ 18],r1,r0,r3, 76, 26); keyiter(k[ 19],r2,r1,r4, 77, 27);
keyiter(k[ 20],r3,r2,r0, 78, 28); keyiter(k[ 21],r4,r3,r1, 79, 29);
keyiter(k[ 22],r0,r4,r2, 80, 30); keyiter(k[ 23],r1,r0,r3, 81, 31);
k += 50;
keyiter(k[-26],r2,r1,r4, 82,-18); keyiter(k[-25],r3,r2,r0, 83,-17);
keyiter(k[-24],r4,r3,r1, 84,-16); keyiter(k[-23],r0,r4,r2, 85,-15);
keyiter(k[-22],r1,r0,r3, 86,-14); keyiter(k[-21],r2,r1,r4, 87,-13);
keyiter(k[-20],r3,r2,r0, 88,-12); keyiter(k[-19],r4,r3,r1, 89,-11);
keyiter(k[-18],r0,r4,r2, 90,-10); keyiter(k[-17],r1,r0,r3, 91, -9);
keyiter(k[-16],r2,r1,r4, 92, -8); keyiter(k[-15],r3,r2,r0, 93, -7);
keyiter(k[-14],r4,r3,r1, 94, -6); keyiter(k[-13],r0,r4,r2, 95, -5);
keyiter(k[-12],r1,r0,r3, 96, -4); keyiter(k[-11],r2,r1,r4, 97, -3);
keyiter(k[-10],r3,r2,r0, 98, -2); keyiter(k[ -9],r4,r3,r1, 99, -1);
keyiter(k[ -8],r0,r4,r2,100, 0); keyiter(k[ -7],r1,r0,r3,101, 1);
keyiter(k[ -6],r2,r1,r4,102, 2); keyiter(k[ -5],r3,r2,r0,103, 3);
keyiter(k[ -4],r4,r3,r1,104, 4); keyiter(k[ -3],r0,r4,r2,105, 5);
keyiter(k[ -2],r1,r0,r3,106, 6); keyiter(k[ -1],r2,r1,r4,107, 7);
keyiter(k[ 0],r3,r2,r0,108, 8); keyiter(k[ 1],r4,r3,r1,109, 9);
keyiter(k[ 2],r0,r4,r2,110, 10); keyiter(k[ 3],r1,r0,r3,111, 11);
keyiter(k[ 4],r2,r1,r4,112, 12); keyiter(k[ 5],r3,r2,r0,113, 13);
keyiter(k[ 6],r4,r3,r1,114, 14); keyiter(k[ 7],r0,r4,r2,115, 15);
keyiter(k[ 8],r1,r0,r3,116, 16); keyiter(k[ 9],r2,r1,r4,117, 17);
keyiter(k[ 10],r3,r2,r0,118, 18); keyiter(k[ 11],r4,r3,r1,119, 19);
keyiter(k[ 12],r0,r4,r2,120, 20); keyiter(k[ 13],r1,r0,r3,121, 21);
keyiter(k[ 14],r2,r1,r4,122, 22); keyiter(k[ 15],r3,r2,r0,123, 23);
keyiter(k[ 16],r4,r3,r1,124, 24); keyiter(k[ 17],r0,r4,r2,125, 25);
keyiter(k[ 18],r1,r0,r3,126, 26); keyiter(k[ 19],r2,r1,r4,127, 27);
keyiter(k[ 20],r3,r2,r0,128, 28); keyiter(k[ 21],r4,r3,r1,129, 29);
keyiter(k[ 22],r0,r4,r2,130, 30); keyiter(k[ 23],r1,r0,r3,131, 31);
/* Apply S-boxes */
S3(r3,r4,r0,r1,r2); storekeys(r1,r2,r4,r3, 28); loadkeys(r1,r2,r4,r3, 24);
S4(r1,r2,r4,r3,r0); storekeys(r2,r4,r3,r0, 24); loadkeys(r2,r4,r3,r0, 20);
S5(r2,r4,r3,r0,r1); storekeys(r1,r2,r4,r0, 20); loadkeys(r1,r2,r4,r0, 16);
S6(r1,r2,r4,r0,r3); storekeys(r4,r3,r2,r0, 16); loadkeys(r4,r3,r2,r0, 12);
S7(r4,r3,r2,r0,r1); storekeys(r1,r2,r0,r4, 12); loadkeys(r1,r2,r0,r4, 8);
S0(r1,r2,r0,r4,r3); storekeys(r0,r2,r4,r1, 8); loadkeys(r0,r2,r4,r1, 4);
S1(r0,r2,r4,r1,r3); storekeys(r3,r4,r1,r0, 4); loadkeys(r3,r4,r1,r0, 0);
S2(r3,r4,r1,r0,r2); storekeys(r2,r4,r3,r0, 0); loadkeys(r2,r4,r3,r0, -4);
S3(r2,r4,r3,r0,r1); storekeys(r0,r1,r4,r2, -4); loadkeys(r0,r1,r4,r2, -8);
S4(r0,r1,r4,r2,r3); storekeys(r1,r4,r2,r3, -8); loadkeys(r1,r4,r2,r3,-12);
S5(r1,r4,r2,r3,r0); storekeys(r0,r1,r4,r3,-12); loadkeys(r0,r1,r4,r3,-16);
S6(r0,r1,r4,r3,r2); storekeys(r4,r2,r1,r3,-16); loadkeys(r4,r2,r1,r3,-20);
S7(r4,r2,r1,r3,r0); storekeys(r0,r1,r3,r4,-20); loadkeys(r0,r1,r3,r4,-24);
S0(r0,r1,r3,r4,r2); storekeys(r3,r1,r4,r0,-24); loadkeys(r3,r1,r4,r0,-28);
k -= 50;
S1(r3,r1,r4,r0,r2); storekeys(r2,r4,r0,r3, 22); loadkeys(r2,r4,r0,r3, 18);
S2(r2,r4,r0,r3,r1); storekeys(r1,r4,r2,r3, 18); loadkeys(r1,r4,r2,r3, 14);
S3(r1,r4,r2,r3,r0); storekeys(r3,r0,r4,r1, 14); loadkeys(r3,r0,r4,r1, 10);
S4(r3,r0,r4,r1,r2); storekeys(r0,r4,r1,r2, 10); loadkeys(r0,r4,r1,r2, 6);
S5(r0,r4,r1,r2,r3); storekeys(r3,r0,r4,r2, 6); loadkeys(r3,r0,r4,r2, 2);
S6(r3,r0,r4,r2,r1); storekeys(r4,r1,r0,r2, 2); loadkeys(r4,r1,r0,r2, -2);
S7(r4,r1,r0,r2,r3); storekeys(r3,r0,r2,r4, -2); loadkeys(r3,r0,r2,r4, -6);
S0(r3,r0,r2,r4,r1); storekeys(r2,r0,r4,r3, -6); loadkeys(r2,r0,r4,r3,-10);
S1(r2,r0,r4,r3,r1); storekeys(r1,r4,r3,r2,-10); loadkeys(r1,r4,r3,r2,-14);
S2(r1,r4,r3,r2,r0); storekeys(r0,r4,r1,r2,-14); loadkeys(r0,r4,r1,r2,-18);
S3(r0,r4,r1,r2,r3); storekeys(r2,r3,r4,r0,-18); loadkeys(r2,r3,r4,r0,-22);
k -= 50;
S4(r2,r3,r4,r0,r1); storekeys(r3,r4,r0,r1, 28); loadkeys(r3,r4,r0,r1, 24);
S5(r3,r4,r0,r1,r2); storekeys(r2,r3,r4,r1, 24); loadkeys(r2,r3,r4,r1, 20);
S6(r2,r3,r4,r1,r0); storekeys(r4,r0,r3,r1, 20); loadkeys(r4,r0,r3,r1, 16);
S7(r4,r0,r3,r1,r2); storekeys(r2,r3,r1,r4, 16); loadkeys(r2,r3,r1,r4, 12);
S0(r2,r3,r1,r4,r0); storekeys(r1,r3,r4,r2, 12); loadkeys(r1,r3,r4,r2, 8);
S1(r1,r3,r4,r2,r0); storekeys(r0,r4,r2,r1, 8); loadkeys(r0,r4,r2,r1, 4);
S2(r0,r4,r2,r1,r3); storekeys(r3,r4,r0,r1, 4); loadkeys(r3,r4,r0,r1, 0);
S3(r3,r4,r0,r1,r2); storekeys(r1,r2,r4,r3, 0);
}
void executor_cpack_align(int n_inter,int n_moles,int n_tstep,double data[][9],int * inter1,int * inter2,ExplicitRelation **sigma)
{
ExplicitRelation * cpack_input_ER;
ExplicitRelation * sigma_ER;
ExplicitRelation * inter1_ER;
ExplicitRelation * inter2_ER;
int i,ii,ii_out0,tstep;
inter1_ER=ER_ctor(inter1,n_inter+-1-0);
inter2_ER=ER_ctor(inter2,n_inter+-1-0);
sigma_ER=*sigma;
/* Define the executor main loop body statments */
/* data[ %(a1)s ][ 3 ] += data[ %(a1)s ][ 0 ] + data[ %(a1)s ][ 6 ];
data[ %(a1)s ][ 4 ] += data[ %(a1)s ][ 1 ] + data[ %(a1)s ][ 7 ];
data[ %(a1)s ][ 5 ] += data[ %(a1)s ][ 2 ] + data[ %(a1)s ][ 8 ];
if (data[ %(a1)s ][ 3 ] < 0.0) data[ %(a1)s ][ 3 ] += side;
if (data[ %(a1)s ][ 3 ] > side) data[ %(a1)s ][ 3 ] -= side;
if (data[ %(a1)s ][ 4 ] < 0.0) data[ %(a1)s ][ 4 ] += side;
if (data[ %(a1)s ][ 4 ] > side) data[ %(a1)s ][ 4 ] -= side;
if (data[ %(a1)s ][ 5 ] < 0.0) data[ %(a1)s ][ 5 ] += side;
if (data[ %(a1)s ][ 5 ] > side) data[ %(a1)s ][ 5 ] -= side;
data[ %(a1)s ][ 0 ] += data[ %(a1)s ][ 6 ];
data[ %(a1)s ][ 1 ] += data[ %(a1)s ][ 7 ];
data[ %(a1)s ][ 2 ] += data[ %(a1)s ][ 8 ];
data[ %(a1)s ][ 6 ] = 0.0;
data[ %(a1)s ][ 7 ] = 0.0;
data[ %(a1)s ][ 8 ] = 0.0; */
/* a1: {[tstep,i]->[sigma_out1]: -1sigma_out1+i=0} */
#define S0(tstep,i) data[ i ][ 3 ] += data[ i ][ 0 ] + data[ i ][ 6 ];\
data[ i ][ 4 ] += data[ i ][ 1 ] + data[ i ][ 7 ];\
data[ i ][ 5 ] += data[ i ][ 2 ] + data[ i ][ 8 ];\
if (data[ i ][ 3 ] < 0.0) data[ i ][ 3 ] += side;\
if (data[ i ][ 3 ] > side) data[ i ][ 3 ] -= side;\
if (data[ i ][ 4 ] < 0.0) data[ i ][ 4 ] += side;\
if (data[ i ][ 4 ] > side) data[ i ][ 4 ] -= side;\
if (data[ i ][ 5 ] < 0.0) data[ i ][ 5 ] += side;\
if (data[ i ][ 5 ] > side) data[ i ][ 5 ] -= side;\
data[ i ][ 0 ] += data[ i ][ 6 ];\
data[ i ][ 1 ] += data[ i ][ 7 ];\
data[ i ][ 2 ] += data[ i ][ 8 ];\
data[ i ][ 6 ] = 0.0;\
data[ i ][ 7 ] = 0.0;\
data[ i ][ 8 ] = 0.0;
/* cutoffSquare = cutoffRadius * cutoffRadius;
n_inter = ninter;
vir = 0.0;
epot = 0.0; */
#define S1(tstep) cutoffSquare = cutoffRadius * cutoffRadius;\
n_inter = ninter;\
vir = 0.0;\
epot = 0.0;
/* xx = data[ %(a31)s ][ 3 ] - data[ %(a32)s ][ 3 ];
yy = data[ %(a31)s ][ 4 ] - data[ %(a32)s ][ 4 ];
zz = data[ %(a31)s ][ 5 ] - data[ %(a32)s ][ 5 ];
if (xx < -sideHalf) xx += side;
if (yy < -sideHalf) yy += side;
if (zz < -sideHalf) zz += side;
if (xx > sideHalf) xx -= side;
if (yy > sideHalf) yy -= side;
if (zz > sideHalf) zz -= side;
rd = (xx * xx + yy * yy + zz * zz);
if (rd < cutoffSquare)
{
rrd = 1.0 / rd;
rrd2 = rrd * rrd;
rrd3 = rrd2 * rrd;
rrd4 = rrd2 * rrd2;
rrd6 = rrd2 * rrd4;
rrd7 = rrd6 * rrd;
r148 = rrd7 - 0.5 * rrd4;
forcex = xx * r148;
forcey = yy * r148;
forcez = zz * r148;
data[ %(a31)s ][ 6 ] += forcex;
data[ %(a31)s ][ 7 ] += forcey;
data[ %(a31)s ][ 8 ] += forcez;
data[ %(a32)s ][ 6 ] -= forcex;
data[ %(a32)s ][ 7 ] -= forcey;
data[ %(a32)s ][ 8 ] -= forcez;
vir -= rd * r148;
epot += (rrd6 - rrd3);
} */
/* a32: {[tstep,ii]->[sigma_out1]: sigma_out1+-1sigma(inter2(ii))=0} */
/* a31: {[tstep,ii]->[sigma_out1]: sigma_out1+-1sigma(inter1(ii))=0} */
#define S2(tstep,ii) xx = data[ ER_out_given_in(sigma_ER,ER_out_given_in(inter1_ER,ii)) ][ 3 ] - data[ ER_out_given_in(sigma_ER,ER_out_given_in(inter2_ER,ii)) ][ 3 ];\
yy = data[ ER_out_given_in(sigma_ER,ER_out_given_in(inter1_ER,ii)) ][ 4 ] - data[ ER_out_given_in(sigma_ER,ER_out_given_in(inter2_ER,ii)) ][ 4 ];\
zz = data[ ER_out_given_in(sigma_ER,ER_out_given_in(inter1_ER,ii)) ][ 5 ] - data[ ER_out_given_in(sigma_ER,ER_out_given_in(inter2_ER,ii)) ][ 5 ];\
if (xx < -sideHalf) xx += side;\
if (yy < -sideHalf) yy += side;\
if (zz < -sideHalf) zz += side;\
if (xx > sideHalf) xx -= side;\
if (yy > sideHalf) yy -= side;\
if (zz > sideHalf) zz -= side;\
rd = (xx * xx + yy * yy + zz * zz);\
if (rd < cutoffSquare) \
{\
rrd = 1.0 / rd;\
rrd2 = rrd * rrd;\
rrd3 = rrd2 * rrd;\
rrd4 = rrd2 * rrd2;\
rrd6 = rrd2 * rrd4;\
rrd7 = rrd6 * rrd;\
r148 = rrd7 - 0.5 * rrd4;\
forcex = xx * r148;\
forcey = yy * r148;\
forcez = zz * r148;\
data[ ER_out_given_in(sigma_ER,ER_out_given_in(inter1_ER,ii)) ][ 6 ] += forcex;\
data[ ER_out_given_in(sigma_ER,ER_out_given_in(inter1_ER,ii)) ][ 7 ] += forcey;\
data[ ER_out_given_in(sigma_ER,ER_out_given_in(inter1_ER,ii)) ][ 8 ] += forcez;\
data[ ER_out_given_in(sigma_ER,ER_out_given_in(inter2_ER,ii)) ][ 6 ] -= forcex;\
data[ ER_out_given_in(sigma_ER,ER_out_given_in(inter2_ER,ii)) ][ 7 ] -= forcey;\
data[ ER_out_given_in(sigma_ER,ER_out_given_in(inter2_ER,ii)) ][ 8 ] -= forcez;\
vir -= rd * r148;\
epot += (rrd6 - rrd3);\
}
/* data[ %(a43)s ][ 6 ] *= timeStepSqHalf;
data[ %(a43)s ][ 7 ] *= timeStepSqHalf;
data[ %(a43)s ][ 8 ] *= timeStepSqHalf;
data[ %(a43)s ][ 0 ] += data[ %(a43)s ][ 6 ];
data[ %(a43)s ][ 1 ] += data[ %(a43)s ][ 7 ];
data[ %(a43)s ][ 2 ] += data[ %(a43)s ][ 8 ]; */
/* a43: {[tstep,i]->[sigma_out1]: -1sigma_out1+i=0} */
#define S3(tstep,i) data[ i ][ 6 ] *= timeStepSqHalf;\
data[ i ][ 7 ] *= timeStepSqHalf;\
data[ i ][ 8 ] *= timeStepSqHalf;\
data[ i ][ 0 ] += data[ i ][ 6 ];\
data[ i ][ 1 ] += data[ i ][ 7 ];\
data[ i ][ 2 ] += data[ i ][ 8 ];
/* The executor main loop */
if (n_tstep >= 1) {
if ((n_inter >= 1) && (n_moles >= 1)) {
for (tstep=0;tstep<=n_tstep-1;tstep++) {
for (i=0;i<=n_moles-1;i++) {
S0(tstep,i);
}
S1(tstep);
for (i=0;i<=n_inter-1;i++) {
S2(tstep,i);
}
for (i=0;i<=n_moles-1;i++) {
S3(tstep,i);
}
}
}
if ((n_inter <= 0) && (n_moles >= 1)) {
for (tstep=0;tstep<=n_tstep-1;tstep++) {
for (i=0;i<=n_moles-1;i++) {
S0(tstep,i);
}
S1(tstep);
for (i=0;i<=n_moles-1;i++) {
S3(tstep,i);
}
}
}
if ((n_inter >= 1) && (n_moles <= 0)) {
for (tstep=0;tstep<=n_tstep-1;tstep++) {
S1(tstep);
for (i=0;i<=n_inter-1;i++) {
S2(tstep,i);
}
}
}
if ((n_inter <= 0) && (n_moles <= 0)) {
for (tstep=0;tstep<=n_tstep-1;tstep++) {
S1(tstep);
}
}
}
/* Undefine the executor main loop body statments */
#undef S0
#undef S1
#undef S2
#undef S3
}
int main()
{
init_arrays();
double annot_t_start=0, annot_t_end=0, annot_t_total=0;
int annot_i;
for (annot_i=0; annot_i<REPS; annot_i++)
{
annot_t_start = rtclock();
#define ceild(n,d) ceil(((double)(n))/((double)(d)))
#define floord(n,d) floor(((double)(n))/((double)(d)))
#define max(x,y) ((x) > (y)? (x) : (y))
#define min(x,y) ((x) < (y)? (x) : (y))
#define S1(zT0,zT1,zT2,zT3,i,j) {B[i][j]=u2[i]*v2[j]+u1[i]*v1[j]+A[i][j];}
#define S2(zT0,zT1,zT2,zT3,i,j) {x[i]=beta*B[j][i]*y[j]+x[i];}
#define S3(i) {x[i]=z[i]+x[i];}
#define S4(i,j) {w[i]=alpha*B[i][j]*x[j]+w[i];}
int c1, c2, c3, c4, c5, c6, c7, c8, c9, c10;
register int lbv, ubv;
/* Generated from PLuTo-produced CLooG file by CLooG v0.14.1 64 bits in 0.05s. */
for (c2=0;c2<=floord(N-1,256);c2++) {
for (c3=0;c3<=floord(N-1,256);c3++) {
for (c4=max(0,8*c2);c4<=min(8*c2+7,floord(N-1,32));c4++) {
for (c5=max(8*c3,0);c5<=min(floord(N-1,32),8*c3+7);c5++) {
/*@ begin Loop(
transform UnrollJam(ufactor=32)
for (c6=max(32*c5,0);c6<=min(N-1,32*c5+31);c6++)
{
{
lbv=max(32*c4,0);
ubv=min(N-1,32*c4+31);
#pragma ivdep
#pragma vector always
for (c7=lbv; c7<=ubv; c7++) {
S1(c3,c2,c5,c4,c6,c7) ;
S2(c2,c3,c4,c5,c7,c6) ;
}
}
}
) @*/{
for (c6 = max(32 * c5, 0); c6 <= min(N - 1, 32 * c5 + 31) - 31; c6 = c6 + 32)
{
lbv=max(32*c4,0);
ubv=min(N-1,32*c4+31);
#pragma ivdep
#pragma vector always
for (c7=lbv; c7<=ubv; c7++) {
S1(c3, c2, c5, c4, c6, c7);
S2(c2, c3, c4, c5, c7, c6);
S1(c3, c2, c5, c4, (c6 + 1), c7);
S2(c2, c3, c4, c5, c7, (c6 + 1));
S1(c3, c2, c5, c4, (c6 + 2), c7);
S2(c2, c3, c4, c5, c7, (c6 + 2));
S1(c3, c2, c5, c4, (c6 + 3), c7);
S2(c2, c3, c4, c5, c7, (c6 + 3));
S1(c3, c2, c5, c4, (c6 + 4), c7);
S2(c2, c3, c4, c5, c7, (c6 + 4));
S1(c3, c2, c5, c4, (c6 + 5), c7);
S2(c2, c3, c4, c5, c7, (c6 + 5));
S1(c3, c2, c5, c4, (c6 + 6), c7);
S2(c2, c3, c4, c5, c7, (c6 + 6));
S1(c3, c2, c5, c4, (c6 + 7), c7);
S2(c2, c3, c4, c5, c7, (c6 + 7));
S1(c3, c2, c5, c4, (c6 + 8), c7);
S2(c2, c3, c4, c5, c7, (c6 + 8));
S1(c3, c2, c5, c4, (c6 + 9), c7);
S2(c2, c3, c4, c5, c7, (c6 + 9));
S1(c3, c2, c5, c4, (c6 + 10), c7);
S2(c2, c3, c4, c5, c7, (c6 + 10));
S1(c3, c2, c5, c4, (c6 + 11), c7);
S2(c2, c3, c4, c5, c7, (c6 + 11));
S1(c3, c2, c5, c4, (c6 + 12), c7);
S2(c2, c3, c4, c5, c7, (c6 + 12));
S1(c3, c2, c5, c4, (c6 + 13), c7);
S2(c2, c3, c4, c5, c7, (c6 + 13));
S1(c3, c2, c5, c4, (c6 + 14), c7);
S2(c2, c3, c4, c5, c7, (c6 + 14));
S1(c3, c2, c5, c4, (c6 + 15), c7);
S2(c2, c3, c4, c5, c7, (c6 + 15));
S1(c3, c2, c5, c4, (c6 + 16), c7);
S2(c2, c3, c4, c5, c7, (c6 + 16));
S1(c3, c2, c5, c4, (c6 + 17), c7);
S2(c2, c3, c4, c5, c7, (c6 + 17));
S1(c3, c2, c5, c4, (c6 + 18), c7);
S2(c2, c3, c4, c5, c7, (c6 + 18));
S1(c3, c2, c5, c4, (c6 + 19), c7);
S2(c2, c3, c4, c5, c7, (c6 + 19));
S1(c3, c2, c5, c4, (c6 + 20), c7);
S2(c2, c3, c4, c5, c7, (c6 + 20));
S1(c3, c2, c5, c4, (c6 + 21), c7);
S2(c2, c3, c4, c5, c7, (c6 + 21));
S1(c3, c2, c5, c4, (c6 + 22), c7);
S2(c2, c3, c4, c5, c7, (c6 + 22));
S1(c3, c2, c5, c4, (c6 + 23), c7);
S2(c2, c3, c4, c5, c7, (c6 + 23));
S1(c3, c2, c5, c4, (c6 + 24), c7);
S2(c2, c3, c4, c5, c7, (c6 + 24));
S1(c3, c2, c5, c4, (c6 + 25), c7);
S2(c2, c3, c4, c5, c7, (c6 + 25));
S1(c3, c2, c5, c4, (c6 + 26), c7);
S2(c2, c3, c4, c5, c7, (c6 + 26));
S1(c3, c2, c5, c4, (c6 + 27), c7);
S2(c2, c3, c4, c5, c7, (c6 + 27));
S1(c3, c2, c5, c4, (c6 + 28), c7);
S2(c2, c3, c4, c5, c7, (c6 + 28));
S1(c3, c2, c5, c4, (c6 + 29), c7);
S2(c2, c3, c4, c5, c7, (c6 + 29));
S1(c3, c2, c5, c4, (c6 + 30), c7);
S2(c2, c3, c4, c5, c7, (c6 + 30));
S1(c3, c2, c5, c4, (c6 + 31), c7);
S2(c2, c3, c4, c5, c7, (c6 + 31));
}
}
for (; c6 <= min(N - 1, 32 * c5 + 31); c6 = c6 + 1)
{
lbv=max(32*c4,0);
ubv=min(N-1,32*c4+31);
#pragma ivdep
#pragma vector always
for (c7=lbv; c7<=ubv; c7++) {
S1(c3, c2, c5, c4, c6, c7);
S2(c2, c3, c4, c5, c7, c6);
}
}
}
/*@ end @*/
}
}
}
}
for (c2=0;c2<=N-1;c2++) {
S3(c2) ;
}
for (c2=0;c2<=N-1;c2++) {
for (c3=0;c3<=N-1;c3++) {
S4(c2,c3) ;
}
}
/* End of CLooG code */
annot_t_end = rtclock();
annot_t_total += annot_t_end - annot_t_start;
}
annot_t_total = annot_t_total / REPS;
printf("%f\n", annot_t_total);
return ((int) w[0]);
}
constexpr S2(const S2&) = default; // expected-error {{defaulted definition of copy constructor is not constexpr}}
constexpr S2(S2&&) = default; // expected-error {{defaulted definition of move constructor is not constexpr}}
NoCopyMove ncm;
};
// If a function is explicitly defaulted on its first declaration
// -- it is implicitly considered to be constexpr if the implicit declaration
// would be
struct S3 {
S3() = default;
S3(const S3&) = default;
S3(S3&&) = default;
constexpr S3(int n) : n(n) {}
int n;
};
constexpr S3 s3a = S3(0);
constexpr S3 s3b = s3a;
constexpr S3 s3c = S3();
constexpr S3 s3d; // expected-error {{default initialization of an object of const type 'const S3' without a user-provided default constructor}} expected-note{{add an explicit initializer to initialize 's3d'}}
struct S4 {
S4() = default;
S4(const S4&) = default; // expected-note {{here}}
S4(S4&&) = default; // expected-note {{here}}
NoCopyMove ncm;
};
constexpr S4 s4a{}; // ok
constexpr S4 s4b = S4(); // expected-error {{constant expression}} expected-note {{non-constexpr constructor}}
constexpr S4 s4c = s4a; // expected-error {{constant expression}} expected-note {{non-constexpr constructor}}
struct S5 {
