static PyObject *
_K_subscript(_K *self, PyObject *key)
{
int i;
K kobj = self->kobj;
char *skey;
int key_length;
int value_index = 1;
if (kobj->t != 5) {
PyErr_Format(PyExc_TypeError,
"k object of type %d is not a dictionary", kobj->t);
return NULL;
}
if (-1 == PyString_AsStringAndSize(key, &skey, &key_length)) {
return NULL;
}
if (skey[key_length-1] == '.') {
--key_length;
++value_index;
}
for (i=0; i < kobj->n; ++i) {
K e = KK(kobj)[i];
if (0 == strncmp(skey,Ks(KK(e)[0]),key_length)) {
PyTypeObject* type = self->ob_type;
_K* k = (_K*)type->tp_alloc(type, 0);
k->kobj = ci(KK(e)[value_index]);
return (PyObject*)k;
}
}
PyErr_SetObject(PyExc_KeyError, key);
return NULL;
}
void dynOneEqEddy::correct(const tmp<volTensorField>& gradU)
{
LESModel::correct(gradU);
const volSymmTensorField D(symm(gradU));
volScalarField KK(0.5*(filter_(magSqr(U())) - magSqr(filter_(U()))));
KK.max(dimensionedScalar("small", KK.dimensions(), SMALL));
const volScalarField P(2.0*nuSgs_*magSqr(D));
tmp<fvScalarMatrix> kEqn
(
fvm::ddt(k_)
+ fvm::div(phi(), k_)
- fvm::laplacian(DkEff(), k_)
==
P
- fvm::Sp(ce(D, KK)*sqrt(k_)/delta(), k_)
);
kEqn().relax();
kEqn().solve();
bound(k_, kMin_);
updateSubGridScaleFields(D, KK);
}
double bdf(double A, double B, int k, int njumps[], double **jumploc, double **p, double h, double u)
{
int j;
double t1,t2,t3,sum;
sum=0;
for (j=0;j<njumps[k];j++)
{
t1=(u-jumploc[k][j])/h;
t2=(u+jumploc[k][j]-2*A)/h;
t3=(2*B-u-jumploc[k][j])/h;
sum+= (KK(t1)+KK(t2)-KK(t3))*p[k][j];
}
return sum;
}
volScalarField dynamicKEqn<BasicTurbulenceModel>::Ce() const
{
const volSymmTensorField D(dev(symm(fvc::grad(this->U_))));
volScalarField KK
(
0.5*(filter_(magSqr(this->U_)) - magSqr(filter_(this->U_)))
);
KK.max(dimensionedScalar("small", KK.dimensions(), SMALL));
return Ce(D, KK);
}
static int
_K_ass_sub(_K *self, PyObject *key, PyObject *value)
{
int i;
K kobj = self->kobj, kval;
char *skey;
int key_length;
int value_index = 1;
if (kobj->t != 5) {
PyErr_Format(PyExc_TypeError,
"k object of type %d is not a dictionary", kobj->t);
return -1;
}
if (-1 == PyString_AsStringAndSize(key, &skey, &key_length)) {
return -1;
}
if (value == NULL) {
PyErr_Format(PyExc_NotImplementedError, "k del key");
return -1;
}
if (_is_k(value)) {
kval = ((_K*)value)->kobj;
} else {
PyErr_Format(PyExc_TypeError, "value is not a k object");
return -1;
}
if (skey[key_length-1] == '.') {
--key_length;
++value_index;
}
for (i=0; i < kobj->n; ++i) {
K e = KK(kobj)[i];
if (0 == strncmp(skey,Ks(KK(e)[0]),key_length)) {
KK(e)[value_index] = ci(kval);
return 0;
}
}
PyErr_SetObject(PyExc_KeyError, key);
return -1;
}
object GetCameraImage(int width, int height, object extrinsic, object oKK)
{
vector<float> vKK = ExtractArray<float>(oKK);
if( vKK.size() != 4 ) {
throw openrave_exception("KK needs to be of size 4");
}
SensorBase::CameraIntrinsics KK(vKK[0],vKK[1],vKK[2],vKK[3]);
vector<uint8_t> memory;
if( !_pviewer->GetCameraImage(memory, width,height,RaveTransform<float>(ExtractTransform(extrinsic)), KK) ) {
throw openrave_exception("failed to get camera image");
}
std::vector<npy_intp> dims(3); dims[0] = height; dims[1] = width; dims[2] = 3;
return toPyArray(memory,dims);
}
void Atelopus::Init(UINT* ar)
{
register int pos1 = 0;
register int pos2 = _bs >> 2;
register int pos3 = _bs >> 1;
register int pos4 = pos2 + pos3;
register UINT val1 = _val1 ^ _bs;
register UINT val2 = _val2 + Atelopus::F1((BYTE)_bs);
BYTE temp[4];
temp[0] = _kk1[16]; temp[1] = _kk1[80]; temp[2] = _kk1[144]; temp[3] = _kk1[208];
register UINT val3;
val3 = Bytes2Word(temp);
val3 ^= Atelopus::F2((BYTE)_bs);
temp[0] = _kk1[48]; temp[1] = _kk1[112]; temp[2] = _kk1[176]; temp[3] = _kk1[240];
register UINT val4;
val4 = Bytes2Word(temp);
val4 += (BYTE)_bs;
UINT *pui1, *pui2, *pui3, *pui4, temp1;
// At least 2 rounds
int len2 = _bs<<1;
int max = (len2 > 256) ? len2 : 256;
for (register int i = 0; i < max; i += 4)
{
pui1 = &ar[pos1]; *pui1 ^= val1; *pui1 += KK(val2);
pui2 = &ar[pos2]; *pui2 ^= val2; *pui2 += KK(val3);
pui3 = &ar[pos3]; *pui3 ^= val3; *pui3 += KK(val4);
pui4 = &ar[pos4]; *pui4 ^= val4; *pui4 += KK(val1);
val1 ^= *pui1; val1 += Atelopus::F1(*pui2); val1 ^= KK(*pui3);
val2 ^= *pui2; val2 += Atelopus::F2(*pui3); val2 ^= KK(*pui4);
val3 ^= *pui3; val3 += Atelopus::F1(*pui4); val3 ^= KK(*pui1);
val4 ^= *pui4; val4 += Atelopus::F2(*pui1); val4 ^= KK(*pui2);
temp[0] = (BYTE)i; temp[1] = (BYTE)(i+1); temp[2] = (BYTE)(i+2); temp[3] = (BYTE)(i+3);
temp1 = Bytes2Word(temp);
(this->*Swap)(temp1, Atelopus::G1(val1 + val2)^Atelopus::G1(val3 + val4));
pos1++;
pos1 &= _bs1;
pos2++;
pos2 &= _bs1;
pos3++;
pos3 &= _bs1;
pos4++;
pos4 &= _bs1;
}
_val1 = val1 ^ val2; _val1 += val3;
_val2 = val2 + val3; _val2 ^= val4;
}
void dynamicKEqn<BasicTurbulenceModel>::correct()
{
if (!this->turbulence_)
{
return;
}
// Local references
const alphaField& alpha = this->alpha_;
const rhoField& rho = this->rho_;
const surfaceScalarField& alphaRhoPhi = this->alphaRhoPhi_;
const volVectorField& U = this->U_;
volScalarField& nut = this->nut_;
fv::options& fvOptions(fv::options::New(this->mesh_));
LESeddyViscosity<BasicTurbulenceModel>::correct();
volScalarField divU(fvc::div(fvc::absolute(this->phi(), U)));
tmp<volTensorField> tgradU(fvc::grad(U));
const volSymmTensorField D(dev(symm(tgradU())));
const volScalarField G(this->GName(), 2.0*nut*(tgradU() && D));
tgradU.clear();
volScalarField KK(0.5*(filter_(magSqr(U)) - magSqr(filter_(U))));
KK.max(dimensionedScalar("small", KK.dimensions(), SMALL));
tmp<fvScalarMatrix> kEqn
(
fvm::ddt(alpha, rho, k_)
+ fvm::div(alphaRhoPhi, k_)
- fvm::laplacian(alpha*rho*DkEff(), k_)
==
alpha*rho*G
- fvm::SuSp((2.0/3.0)*alpha*rho*divU, k_)
- fvm::Sp(Ce(D, KK)*alpha*rho*sqrt(k_)/this->delta(), k_)
+ kSource()
+ fvOptions(alpha, rho, k_)
);
kEqn.ref().relax();
fvOptions.constrain(kEqn.ref());
solve(kEqn);
fvOptions.correct(k_);
bound(k_, this->kMin_);
correctNut(D, KK);
}
// Convert a Qt::Key_XXX code into the corresponding Linux keycode value.
// On failure, return -1.
static int convertKeyCode(int sym)
{
#define KK(x,y) { Qt::Key_ ## x, KEY_ ## y }
#define K1(x) KK(x,x)
static const struct {
int qt_sym;
int keycode;
} kConvert[] = {
KK(Left, LEFT),
KK(Right, RIGHT),
KK(Up, UP),
KK(Down, DOWN),
K1(0),
K1(1),
K1(2),
K1(3),
K1(4),
K1(5),
K1(6),
K1(7),
K1(8),
K1(9),
K1(F1),
K1(F2),
K1(F3),
K1(F4),
K1(F5),
K1(F6),
K1(F7),
K1(F8),
K1(F9),
K1(F10),
K1(F11),
K1(F12),
K1(A),
K1(B),
K1(C),
K1(D),
K1(E),
K1(F),
K1(G),
K1(H),
K1(I),
K1(J),
K1(K),
K1(L),
K1(M),
K1(N),
K1(O),
K1(P),
K1(Q),
K1(R),
K1(S),
K1(T),
K1(U),
K1(V),
K1(W),
K1(X),
K1(Y),
K1(Z),
KK(Minus, MINUS),
KK(Equal, EQUAL),
KK(Backspace, BACKSPACE),
KK(Home, HOME),
KK(Escape, ESC),
KK(Comma, COMMA),
KK(Period,DOT),
KK(Space, SPACE),
KK(Slash, SLASH),
KK(Return,ENTER),
KK(Tab, TAB),
KK(BracketLeft, LEFTBRACE),
KK(BracketRight, RIGHTBRACE),
KK(Backslash, BACKSLASH),
KK(Semicolon, SEMICOLON),
KK(Apostrophe, APOSTROPHE),
};
const size_t kConvertSize = sizeof(kConvert) / sizeof(kConvert[0]);
size_t nn;
for (nn = 0; nn < kConvertSize; ++nn) {
if (sym == kConvert[nn].qt_sym) {
return kConvert[nn].keycode;
}
}
return -1;
}
void Atelopus::HashPrimitive(UINT const* data, UINT* res)
{
// Copy in work buffer
UINT ar[BlockSize256];
memcpy(ar, data, _bs4);
// 1) Propagate differences
register UINT temp1, temp2;
register int i, k, ix, ix1, pos1, pos2, incr1, incr2;
for (k = 0; k < (int)_iter; k++)
{
if (k == 1)
{
// Introduce a data difference based on _size
ar[0] ^= KK(_size);
}
ix = H1(Atelopus::F1(_val1) ^ KK(_val2)) & _bs1;
ix1 = (ix + _bs2) & _bs1;
incr1 = H1(KK(_val1) ^ _val2) & _bs1;
incr2 = H2(_val1 + KK(_val2)) & _bs1;
pos1 = H1(_val1) & _bs1;
pos2 = H2(Atelopus::F2(_val2)) & _bs1;
if ((incr1 == incr2) && (pos1 == pos2))
{
pos2++;
pos2 &= _bs1;
}
for (i=0; i<(int)_bs; i++)
{
if (pos1 == pos2)
{
temp1 = ar[pos1];
_val1 ^= KK(temp1);
_val1 += ar[ix];
_val2 ^= Atelopus::F1(_val1);
_val2 += temp1;
_val2 ^= ar[ix1];
temp1 ^= KK(_val1);
ar[pos1] = temp1 + KK(_val2);
(this->*Swap)(temp1, _val2);
}
else
{
temp1 = ar[pos1];
temp2 = ar[pos2];
_val1 ^= KK(temp1);
_val1 += ar[ix];
_val2 ^= Atelopus::F1(_val1);
_val2 += temp2;
_val2 ^= ar[ix1];
ar[pos2] = temp2 + KK(_val2);
(this->*Swap)((ar[pos1] = temp1 ^ KK(_val1)), _val2);
}
if (i < (int)_bs1)
{
ix++;
ix &= _bs1;
ix1++;
ix1 &= _bs1;
pos1 += incr1;
pos1 &= _bs1;
pos2 += incr2;
pos2 &= _bs1;
}
}
}
// 2) Contracting (assuming _size < len, but it can also expand)
incr1 = H1(KK(_val1) ^ _val2) & _bs1;
incr2 = H2(_val1 + KK(_val2)) & _bs1;
pos1 = H1(_val1) & _bs1;
pos2 = H2(Atelopus::F2(_val2)) & _bs1;
if ((incr1 == incr2) && (pos1 == pos2))
{
pos2++;
pos2 &= _bs1;
}
int ik, pk;
ik = H1(KK(Atelopus::F1(_val1)) + _val2) & _size1;
pk = H1(Atelopus::F1(_val1) ^ KK(_val2)) & _size1;
int max = (_bs2 < _size) ? _size : (_bs2+1);
register bool over = false;
int sz = _size - _bs;
i=0; k=pk; ix=_bs2;
for (ix1=0; ix1<max; ix1++)
{
temp1 = ar[pos1];
_val1 ^= KK(temp1);
_val1 += ar[i];
_val2 ^= Atelopus::F2(_val1);
if (over)
{
res[k] += _val2;
}
else
{
res[k] = _val2;
}
_val2 += ar[pos2];
_val2 ^= ar[ix];
if (sz > 0)
{
// Only for expansion
ar[i] ^= KK(_val2);
ar[ix] += Atelopus::F1(_val1);
}
(this->*Swap)(temp1 ^ KK(_val1), _val2);
i++;
i &= _bs1;
if (i == 0)
{
sz -= _bs;
}
k += ik;
k &= _size1;
if (k == pk)
{
over = true;
}
ix++,
ix &= _bs1;
pos1+=incr1;
pos1 &= _bs1;
pos2+=incr2;
pos2 &= _bs1;
}
// 3) Combining with the original
incr1 = H1(KK(_val1)) & _bs1;
incr2 = H2(KK(_val2)) & _size1;
i = H1(Atelopus::F1(_val1)) & _bs1;
k = H2(_val2) & _size1;
max = (_bs < _size) ? _size : _bs;
for (ix = 0; ix < max; ix++)
{
temp1 = data[i];
_val1 += KK(temp1);
_val2 ^= Atelopus::F1(_val1 + temp1);
res[k] ^= _val2;
i += incr1;
i &= _bs1;
k += incr2;
k &= _size1;
}
}
// Convert an SDLK_XXX code into the corresponding Linux keycode value.
// On failure, return -1.
static int sdl_sym_to_key_code(int sym) {
#define KK(x,y) { SDLK_ ## x, KEY_ ## y }
#define K1(x) KK(x,x)
static const struct {
int sdl_sym;
int keycode;
} kConvert[] = {
K1(LEFT),
K1(RIGHT),
K1(UP),
K1(DOWN),
K1(KP0),
K1(KP1),
K1(KP2),
K1(KP3),
K1(KP4),
K1(KP5),
K1(KP6),
K1(KP7),
K1(KP8),
K1(KP9),
KK(KP_MINUS,KPMINUS),
KK(KP_PLUS,KPPLUS),
KK(KP_MULTIPLY,KPASTERISK),
KK(KP_DIVIDE,KPSLASH),
KK(KP_EQUALS,KPEQUAL),
KK(KP_PERIOD,KPDOT),
KK(KP_ENTER,KPENTER),
KK(ESCAPE,ESC),
K1(0),
K1(1),
K1(2),
K1(3),
K1(4),
K1(5),
K1(6),
K1(7),
K1(8),
K1(9),
K1(MINUS),
KK(EQUALS,EQUAL),
K1(BACKSPACE),
K1(HOME),
KK(ESCAPE,ESC),
K1(F1),
K1(F2),
K1(F3),
K1(F4),
K1(F5),
K1(F6),
K1(F7),
K1(F8),
K1(F9),
K1(F10),
K1(F11),
K1(F12),
KK(a,A),
KK(b,B),
KK(c,C),
KK(d,D),
KK(e,E),
KK(f,F),
KK(g,G),
KK(h,H),
KK(i,I),
KK(j,J),
KK(k,K),
KK(l,L),
KK(m,M),
KK(n,N),
KK(o,O),
KK(p,P),
KK(q,Q),
KK(r,R),
KK(s,S),
KK(t,T),
KK(u,U),
KK(v,V),
KK(w,W),
KK(x,X),
KK(y,Y),
KK(z,Z),
K1(COMMA),
KK(PERIOD,DOT),
K1(SPACE),
K1(SLASH),
KK(RETURN,ENTER),
K1(TAB),
KK(BACKQUOTE,GRAVE),
KK(LEFTBRACKET,LEFTBRACE),
KK(RIGHTBRACKET,RIGHTBRACE),
K1(BACKSLASH),
K1(SEMICOLON),
KK(QUOTE,APOSTROPHE),
KK(RSHIFT,RIGHTSHIFT),
KK(LSHIFT,LEFTSHIFT),
KK(RMETA,COMPOSE),
KK(LMETA,COMPOSE),
KK(RALT,RIGHTALT),
KK(LALT,LEFTALT),
KK(RCTRL,RIGHTCTRL),
KK(LCTRL,LEFTCTRL),
K1(NUMLOCK),
};
const size_t kConvertSize = sizeof(kConvert) / sizeof(kConvert[0]);
size_t nn;
for (nn = 0; nn < kConvertSize; ++nn) {
if (sym == kConvert[nn].sdl_sym) {
return kConvert[nn].keycode;
}
}
return -1;
}
static PyObject*
_ktoarray(PyObject* self, PyObject* k)
{
PyArrayObject *ret;
if (!PyK_KCheck(k)) {
return PyErr_Format(PyExc_TypeError, "not k object");
}
K kobj = ((PyK_K*)k)->kobj;
if (!kobj) {
return PyErr_Format(PyExc_AssertionError, "null kobj");
}
int t = kobj->t;
/* XXX k objects of type 0 should be converted
* to non-contiguous arrays rather than trigger
* an error.
*/
if (abs(t) >= LEN(types) && t != 5 ) {
return PyErr_Format(PyExc_TypeError,
"cannot create an array from a "
"k object of type %d", t);
}
int type = types[abs(t)]; /* PyArray type */
int nd = t <= 0 || t == 5; /* Number of dimensions (0 or 1) */
int* d = &kobj->n; /* Shape */
char* data;
switch (t) {
case 1:
data = (char*)&Ki(kobj);
break;
case 3:
data = &Kc(kobj);
break;
case 4:
data = Ks(kobj);
break;
default:
data = KC(kobj);
}
/* Special handling for symbols arrays: convert data to Python strings */
PyObject** buf = 0;
if (t == -4) {
int n = *d, i = 0;
buf = (PyObject**)malloc(n * sizeof(PyObject*));
for (i = 0; i < n; ++i) {
char* s = KS(kobj)[i];
if (!s) goto fail;
buf[i] = PyString_FromString(s);
if (!buf[i]) goto fail;
}
data = (char*)buf;
} else if (t == 0 || t == 5) {
int n = *d, i = 0;
buf = (PyObject**)malloc(n * sizeof(PyObject*));
for (i = 0; i < n; ++i) {
K ki = KK(kobj)[i];
if (!ki) goto fail;
ci(ki);
buf[i] = PyK_mk_K(ki);
if (!buf[i]) {
cd(ki);
goto fail;
}
}
data = (char*)buf;
}
if (!(ret = (PyArrayObject *)PyArray_FromDimsAndData(nd, d, type, data))) {
goto fail;
}
if (buf) {
ret->flags |= OWN_DATA;
} else {
Py_INCREF(k);
ret->base = k;
}
return (PyObject*)ret;
fail:
if (buf) free(buf);
return NULL;
}
/* XXX unfortunately API function gnk of which pyk.gk
is based is a vararg function and therefore cannot
be portably exported to Python. It would be better
if libk20 supplied a function gnk_(I, K*)
in addition to gnk(I,...) which would take an array
of K objects as the second argument */
static PyObject*
_gk(PyObject* self, PyObject* args)
{
int n = PyTuple_Size(args);
if (!n) {
return _mk_K(gtn(0,0));
}
int i, type = INT_MAX;
K* ks = (K*)malloc(n*sizeof(K));
K kobj;
for(i = 0; i < n; i++) {
K ki;
int t;
PyObject* argi = PyTuple_GET_ITEM(args, i);
if (!IS_K(argi)) {
goto fail;
}
ks[i] = ki = ((_K*)argi)->kobj;
t = ki->t;
if (INT_MAX == type) {
type = t;
} else if (t > 4 || t < 1 || t != type) {
type = 0;
}
}
kobj = gtn((type>0 && type<5)?-type:0, n);
if (!kobj) {
free(ks);
return PyErr_Format(PyExc_TypeError, "gtn(%d,%d) returned null", -type, n);
}
switch (type) {
case 1:
for (i = 0; i < n; i++) {
KI(kobj)[i] = Ki(ks[i]);
}
break;
case 2:
for (i = 0; i < n; i++) {
KF(kobj)[i] = Kf(ks[i]);
}
break;
case 3:
for (i = 0; i < n; i++) {
KC(kobj)[i] = Kc(ks[i]);
}
break;
case 4:
for (i = 0; i < n; i++) {
KS(kobj)[i] = Ks(ks[i]);
}
break;
default:
memcpy(KK(kobj), ks, n*sizeof(K));
for (i = 0; i < n; i++) {
ci(ks[i]);
}
break;
}
free(ks);
return _mk_K(kobj);
fail:
free(ks);
PyErr_BadArgument();
return NULL;
}
int
main(int argc, char** argv)
{
F pi = atan(1.0)*4;
K a = gi(2);
K b = gi(3);
K c = gi(4);
K* v;
cd(ksk("",0));
tst(Ki(a)==2);
tst(Ki(b) + 1 == Ki(c));
cd(a); cd(b); cd(c);
b = gf(1.0); c = gf(2);
tst(Kf(b) + 1 == Kf(c));
cd(b); cd(c);
a = gs(sp("foo"));
b = ksk("`foo", 0);
tst(Ks(a) == Ks(b));
cd(a); cd(b);
a = ksk("2 + 3", 0);
tst(Ki(a) == 5);
cd(a);
a = ksk("_ci 65", 0);
tst(Kc(a) == 'A');
// XXX this should return type 1 uniform vector
a=gnk(3,gi(11),gi(22),gi(33));
tst(a->t == 0);
v = (K*)a->k;
tst(Ki(v[0])+Ki(v[1])==Ki(v[2]));
cd(a);
{
b = gsk("pi",gf(pi));
kap(&KTREE, &b);
a = X(".pi");
tst(Kf(a) == pi);
cd(a);
}
{
K dir = gtn(5,0);
K t;
t = gsk("x",gi(1)); kap(&dir, &t);
t = gsk("y",gi(2)); kap(&dir, &t);
t = gsk("z",dir); kap(&KTREE, &t);
a = X(".z.x");
tst(Ki(a) == 1);
cd(a);
a = X(".z.y");
tst(Ki(a) == 2);
cd(a);
}
{
I i;
K d = gtn(5,0);
K c0 = gtn(0,0);
K c1 = gtn(-1,0);
K t0, t1, e;
t0 = gsk("a", c0); kap(&d,&t0);
t1 = gsk("b", c1); kap(&d,&t1);
e = gp("hello1"); kap(&c0,&e);
e = gp("hello2"); kap(&c0,&e);
KK(KK(d)[0])[1] = c0;
i = 1; kap(&KK(KK(d)[1])[1], &i);
i = 2; kap(&KK(KK(d)[1])[1], &i);
//i = 1; kap(&c1, &i);
//i = 2; kap(&c1, &i);
//KK(KK(d)[1])[1] = c1;
show(d);
}
//b = ksk("+/", a);
//tst(Ki(b) == 66);
//argc--;argv++;
//DO(i, argc, {a=ksk(argv[i], 0);
//ksk("`0:,/$!10;`0:,\"\n\"", 0);
fprintf(stderr, "Pass:%4d, fail:%4d\n", pass, fail);
if (argc > 1 && strcmp(argv[1], "-i") == 0) {
boilerplate();
attend();
}
}
