int Z3_API Z3_algebraic_eval(Z3_context c, Z3_ast p, unsigned n, Z3_ast a[]) {
Z3_TRY;
LOG_Z3_algebraic_eval(c, p, n, a);
RESET_ERROR_CODE();
polynomial::manager & pm = mk_c(c)->pm();
polynomial_ref _p(pm);
polynomial::scoped_numeral d(pm.m());
expr2polynomial converter(mk_c(c)->m(), pm, 0, true);
if (!converter.to_polynomial(to_expr(p), _p, d) ||
static_cast<unsigned>(max_var(_p)) >= n) {
SET_ERROR_CODE(Z3_INVALID_ARG);
return 0;
}
algebraic_numbers::manager & _am = am(c);
scoped_anum_vector as(_am);
if (!to_anum_vector(c, n, a, as)) {
SET_ERROR_CODE(Z3_INVALID_ARG);
return 0;
}
{
cancel_eh<algebraic_numbers::manager> eh(_am);
api::context::set_interruptable si(*(mk_c(c)), eh);
scoped_timer timer(mk_c(c)->params().m_timeout, &eh);
vector_var2anum v2a(as);
int r = _am.eval_sign_at(_p, v2a);
if (r > 0) return 1;
else if (r < 0) return -1;
else return 0;
}
Z3_CATCH_RETURN(0);
}
Z3_ast_vector Z3_API Z3_algebraic_roots(Z3_context c, Z3_ast p, unsigned n, Z3_ast a[]) {
Z3_TRY;
LOG_Z3_algebraic_roots(c, p, n, a);
RESET_ERROR_CODE();
polynomial::manager & pm = mk_c(c)->pm();
polynomial_ref _p(pm);
polynomial::scoped_numeral d(pm.m());
expr2polynomial converter(mk_c(c)->m(), pm, 0, true);
if (!converter.to_polynomial(to_expr(p), _p, d) ||
static_cast<unsigned>(max_var(_p)) >= n + 1) {
SET_ERROR_CODE(Z3_INVALID_ARG);
return 0;
}
algebraic_numbers::manager & _am = am(c);
scoped_anum_vector as(_am);
if (!to_anum_vector(c, n, a, as)) {
SET_ERROR_CODE(Z3_INVALID_ARG);
return 0;
}
scoped_anum_vector roots(_am);
{
cancel_eh<algebraic_numbers::manager> eh(_am);
api::context::set_interruptable si(*(mk_c(c)), eh);
scoped_timer timer(mk_c(c)->params().m_timeout, &eh);
vector_var2anum v2a(as);
_am.isolate_roots(_p, v2a, roots);
}
Z3_ast_vector_ref* result = alloc(Z3_ast_vector_ref, mk_c(c)->m());
mk_c(c)->save_object(result);
for (unsigned i = 0; i < roots.size(); i++) {
result->m_ast_vector.push_back(au(c).mk_numeral(roots.get(i), false));
}
RETURN_Z3(of_ast_vector(result));
Z3_CATCH_RETURN(0);
}
circle::circle(float x0,float y0,float angle,float speed,pic* image,int num,bool aim,int _layer)
{
int i;
if(aim) angle+=v2a(estg->self->x-x0,estg->self->y-y0);
if(num%2==0) angle+=2.0/num;
for(i=0;i<num;i++)
estg->add(new straight_bullet(x0,y0,angle+4.0/num*i,speed,image,false,0.0,0.0,0.0,_layer));
dead=true;
}
/*!
* \brief LAArmadillo::substract
* Substract v2 from v1
* \param result
* \param v1
* \param v2
*/
void LAArmadillo::substract(OiVec &result, const OiVec &v1, const OiVec &v2){
int vecSize = v1.getSize();
arma::vec v1a(vecSize), v2a(vecSize);
this->oiVec2Arma(v1a, v1);
this->oiVec2Arma(v2a, v2);
this->arma2OiVec(result, (v1a - v2a));
}
void straight_self_bullet::aim()
{
if((estg->self->sres.blt["tar1"]!=0)&&_type==1)
{
cx=real_x;
cy=real_y;
crot=v2a(((bullet*)(estg->self->sres.blt["tar1"]))->real_x-cx,((bullet*)(estg->self->sres.blt["tar1"]))->real_y-cy);
age=1;
return;
}
if((estg->self->sres.blt["tar2"]!=0)&&_type==2)
{
cx=real_x;
cy=real_y;
crot=v2a(((bullet*)(estg->self->sres.blt["tar2"]))->real_x-cx,((bullet*)(estg->self->sres.blt["tar2"]))->real_y-cy);
age=1;
return;
}
}
virtual void makeRectangle2D(const Matrix& mat) {
for (size_t surf = 0; surf < 5; ++surf) {
gobj::Rectangle3D& rect = m_rect[surf];
for (size_t pt = 0; pt < 4; ++pt) {
Vector3D v(getVertex(ts::gobj::Building3D::rectIndics[surf][pt]));
v = mat.mult2d(v);
v.z = 999.0f;
rect.setVertex(pt, v);
}
Vector2D v2a(rect.getVertex(1) - rect.getVertex(0));
Vector2D v2b(rect.getVertex(2) - rect.getVertex(1));
if (v2a.cross(v2b) < 0.0f) {
rect.disable();
}
else {
rect.enable();
}
rect.setLineWidth(3.0f);
rect.setColor(ColorRGBA(255,255,0,255));
}
}
// convert a VARIANT to a J array
// returns 0 on error with detail in jerr.
static A v2a(J jt, VARIANT* v, int dobstrs)
{
A a;
SAFEARRAY* psa;
SAFEARRAYBOUND* pb;
I shape[MAXRANK];
I k=1,n,r,i;
I* pintsnk;
#if SY_64
int* pint32src;
#else
long long* pint64src;
#endif
short* pshortsrc;
unsigned short* pboolsrc;
char* pboolsnk;
VARTYPE t;
int byref;
double* pdoublesnk;
float* pfloatsrc;
#define OPTREF(v,field) (byref ? *v->p##field : v->field)
t=v->vt;
byref = t & VT_BYREF;
t = t & ~VT_BYREF;
if(dobstrs && t == VT_BSTR)
{
BSTR bstr; int len;
bstr = OPTREF(v,bstrVal);
if(uniflag)
// len=SysStringLen(bstr);
len=WideCharToMultiByte(CP_UTF8,0,bstr,(int)SysStringLen(bstr),0,0,0,0);
else
len=SysStringByteLen(bstr);
RE(a=ga(LIT, len, 1, 0));
if(uniflag)
toutf8n(bstr, (C*)AV(a), len);
else
memcpy((C*)AV(a), (C*)bstr, len);
R a;
}
if(t & VT_ARRAY)
{
psa = OPTREF(v,parray);
pb = psa->rgsabound;
r=psa->cDims;
ASSERT(r<=MAXRANK,EVRANK);
for(i=0; i<r; ++i)
{
n = pb[i].cElements;
shape[i] = n;
k *= n;
}
}
else
r = 0;
switch(t)
{
case VT_VARIANT | VT_ARRAY:
{
A *boxes;
VARIANT* pv;
// fixup scalar boxes which arrive
// as a 1-elem vector with a lower bound at -1, not 0.
if (pb[0].lLbound == -1)
{
ASSERT(psa->cDims==1 && pb[0].cElements==1, EVDOMAIN);
r = 0;
}
RE(a=ga(BOX, k, r, (I*)&shape));
ASSERT(S_OK==SafeArrayAccessData(psa, &pv),EVFACE);
boxes = AAV(a);
while(k--)
{
A z;
// Don't use a PROLOG/EPILOG during v2a.
// The z's are not getting their reference
// count set until everything is in place
// and the jset() is done in Jset().
z = *boxes++ = v2a(jt, pv++, dobstrs);
if (!z) break;
}
SafeArrayUnaccessData(psa);
if (jt->jerr) return 0;
break;
}
case VT_BOOL | VT_ARRAY:
RE(a=ga(B01, k, r, (I*)&shape));
pboolsrc = (VARIANT_BOOL*)psa->pvData;
pboolsnk = BAV(a);
// J bool returned from VB boolean, a -1 and 0 mess.
// It wouldn't be that bad if the Microsoft folks used their own macros
// and kept an eye an sign extensions. But the way they are
// doing it they are returning at least some TRUEs as value 255
// instead of VARIANT_TRUE. Therefore, we have to compare against
// VARIANT_FALSE which -we hope- is consistently defined (as 0).
while(k--)
*pboolsnk++ = (*pboolsrc++)!=VARIANT_FALSE;
break;
case VT_UI1 | VT_ARRAY:
RE(a=ga(LIT, k, r, (I*)&shape));
memcpy(AV(a), psa->pvData, k * sizeof(char));
break;
case VT_UI2 | VT_ARRAY:
RE(a=ga(C2T, k, r, (I*)&shape));
memcpy(AV(a), psa->pvData, k * sizeof(short));
break;
case VT_UI4 | VT_ARRAY:
RE(a=ga(C4T, k, r, (I*)&shape));
memcpy(AV(a), psa->pvData, k * sizeof(int));
break;
case VT_I2 | VT_ARRAY:
RE(a=ga(INT, k, r, (I*)&shape));
pshortsrc = (short*)psa->pvData;
pintsnk = AV(a);
while(k--)
*pintsnk++ = *pshortsrc++;
break;
case VT_I4 | VT_ARRAY:
RE(a=ga(INT, k, r, (I*)&shape));
#if SY_64
pint32src = (long*)psa->pvData;
pintsnk = AV(a);
while(k--)
*pintsnk++ = *pint32src++;
#else
memcpy(AV(a), psa->pvData, k * sizeof(int));
#endif
break;
case VT_I8 | VT_ARRAY:
RE(a=ga(INT, k, r, (I*)&shape));
#if SY_64
memcpy(AV(a), psa->pvData, k * sizeof(I));
#else
pint64src = (long long*)psa->pvData;
pintsnk = AV(a);
while(k--)
*pintsnk++ = (I)*pint64src++;
#endif
break;
case VT_R4 | VT_ARRAY:
RE(a=ga(FL, k, r, (I*)&shape));
pfloatsrc = (float*)psa->pvData;
pdoublesnk = (double*)AV(a);
while(k--)
*pdoublesnk++ = *pfloatsrc++;
break;
case VT_R8 | VT_ARRAY:
RE(a=ga(FL, k, r, (I*)&shape));
memcpy(AV(a), psa->pvData, k * sizeof(double));
break;
case VT_UI1:
RE(a=ga(LIT, 1, 0, 0));
*CAV(a) = OPTREF(v,bVal);
break;
case VT_UI2:
RE(a=ga(C2T, 1, 0, 0));
*USAV(a) = (US)OPTREF(v,iVal);
break;
case VT_UI4:
RE(a=ga(C4T, 1, 0, 0));
*C4AV(a) = (C4)OPTREF(v,lVal);
break;
case VT_BOOL:
RE(a=ga(B01, 1, 0, 0));
// array case above explains this messy phrase:
*BAV(a) = OPTREF(v,boolVal)!=VARIANT_FALSE;
break;
case VT_I2:
RE(a=ga(INT, 1, 0, 0));
*IAV(a) = OPTREF(v,iVal);
break;
case VT_I4:
RE(a=ga(INT, 1, 0, 0));
*IAV(a) = OPTREF(v,lVal);
break;
case VT_I8:
RE(a=ga(INT, 1, 0, 0));
*IAV(a) = (I)OPTREF(v,llVal);
break;
case VT_R4:
RE(a=ga(FL, 1, 0, 0));
*DAV(a) = OPTREF(v,fltVal);
break;
case VT_R8:
RE(a=ga(FL, 1, 0, 0));
*DAV(a) = OPTREF(v,dblVal);
break;
default:
ASSERT(0,EVDOMAIN);
}
if(1<r && jt->transposeflag)
{
RE(a=cant1(a));
DO(r, AS(a)[i]=shape[r-1-i];);
bool runUnitTests() {
// vector addition
Vector2 v2a(13.5f, -48.23f), v2b(5, 3.99f), v2c;
v2c = v2a + v2b;
Vector3 v3a(13.5f, -48.23f, 862), v3b(5, 3.99f, -12), v3c;
v3c = v3a + v3b;
Vector4 v4a(13.5f, -48.23f, 862, 0), v4b(5, 3.99f, -12, 1), v4c;
v4c = v4a + v4b;
TEST("Vector2 addition", v2c, Vector2(18.5f,-44.24f));
TEST("Vector3 addition", v3c, Vector3(18.5f,-44.24f,850));
TEST("Vector4 addition", v4c, Vector4(18.5f,-44.24f,850,1));
// vector subtraction
v2a = Vector2(13.5f, -48.23f); v2b = Vector2(5, 3.99f);
v2c = v2a - v2b;
v3a = Vector3(13.5f, -48.23f, 862); v3b = Vector3(5, 3.99f, -12);
v3c = v3a - v3b;
v4a = Vector4(13.5f, -48.23f, 862, 0); v4b = Vector4(5, 3.99f, -12, 1);
v4c = v4a - v4b;
TEST("Vector2 subtraction", v2c, Vector2(8.5f,-52.22f));
TEST("Vector3 subtraction", v3c, Vector3(8.5f,-52.22f,874));
TEST("Vector4 subtraction", v4c, Vector4(8.5f,-52.22f,874,-1));
// vector post-scale
v2a = Vector2(13.5f, -48.23f);
v2c = v2a * 2.482f;
v3a = Vector3(13.5f, -48.23f, 862);
v3c = v3a * 0.256f;
v4a = Vector4(13.5f, -48.23f, 862, 0);
v4c = v4a * 4.89f;
TEST("Vector2 post-scale", v2c, Vector2(33.5069999695f, -119.706863403f));
TEST("Vector3 post-scale", v3c, Vector3(3.45600008965f, -12.3468809128f, 220.672012329f));
TEST("Vector4 post-scale", v4c, Vector4(66.0149993896f, -235.844696045f, 4215.1796875f, 0));
// vector pre-scale
v2a = Vector2(13.5f, -48.23f);
v2c = 2.482f * v2a;
v3a = Vector3(13.5f, -48.23f, 862);
v3c = 0.256f * v3a;
v4a = Vector4(13.5f, -48.23f, 862, 0);
v4c = 4.89f * v4a;
TEST("Vector2 pre-scale", v2c, Vector2(33.5069999695f, -119.706863403f));
TEST("Vector3 pre-scale", v3c, Vector3(3.45600008965f, -12.3468809128f, 220.672012329f));
TEST("Vector4 pre-scale", v4c, Vector4(66.0149993896f, -235.844696045f, 4215.1796875f, 0));
// vector dot product
v2a = Vector2(13.5f, -48.23f); v2b = Vector2(5, 3.99f);
float dot2 = v2a.dot(v2b);
v3a = Vector3(13.5f, -48.23f, 862); v3b = Vector3(5, 3.99f, -12);
float dot3 = v3a.dot(v3b);
v4a = Vector4(13.5f, -48.23f, 862, 0); v4b = Vector4(5, 3.99f, -12, 1);
float dot4 = v4a.dot(v4b);
TEST("Vector2 dot", dot2, -124.937698364f);
TEST("Vector3 dot", dot3, -10468.9375f);
TEST("Vector4 dot", dot4, -10468.9375f);
// vector cross product
v3a = Vector3(13.5f, -48.23f, 862); v3b = Vector3(5, 3.99f, -12);
v3c = v3a.cross(v3b);
v4a = Vector4(13.5f, -48.23f, 862, 0); v4b = Vector4(5, 3.99f, -12, 1);
v4c = v4a.cross(v4b);
TEST("Vector3 cross", v3c, Vector3(-2860.62011719f, 4472.00000000f, 295.01498413f));
TEST("Vector4 cross", v4c, Vector4(-2860.62011719f, 4472.00000000f, 295.01498413f, 0));
// vector magnitude
v2a = Vector2(13.5f, -48.23f);
float mag2 = v2a.magnitude();
v3a = Vector3(13.5f, -48.23f, 862);
float mag3 = v3a.magnitude();
v4a = Vector4(13.5f, -48.23f, 862, 0);
float mag4 = v4a.magnitude();
TEST("Vector2 magnitude", mag2, 50.0837593079f);
TEST("Vector3 magnitude", mag3, 863.453735352f);
TEST("Vector4 magnitude", mag4, 863.453735352f);
// vector normalise
v2a = Vector2(-13.5f, -48.23f);
v2a.normalise();
v3a = Vector3(13.5f, -48.23f, 862);
v3a.normalise();
v4a = Vector4(243, -48.23f, 862, 0);
v4a.normalise();
TEST("Vector2 normalise", v2a, Vector2(-0.269548f,-0.962987f));
TEST("Vector3 normalise", v3a, Vector3(0.0156349f,-0.0558571f,0.998316f));
TEST("Vector4 normalise", v4a, Vector4(0.270935f,-0.0537745f,0.961094f,0));
// matrix rotation
Matrix2 m2;
Matrix3 m3a, m3b, m3c, m3d;
Matrix4 m4a, m4b, m4c, m4d;
m2.setRotateZ(4.576f);
m3a.setRotateX(3.98f);
m4a.setRotateX(4.5f);
m3b.setRotateY(1.76f);
m4b.setRotateY(-2.6f);
m3c.setRotateZ(9.62f);
m4c.setRotateZ(0.72f);
TEST("Matrix2 set rotate", m2, Matrix2(-0.135966f,-0.990713f,0.990713f,-0.135966f));
TEST("Matrix3 set rotate", m3a, Matrix3(1,0,0,0,-0.668648f,-0.743579f,0,0.743579f,-0.668648f));
TEST("Matrix3 set rotate", m3b, Matrix3(-0.188077f,0,-0.982154f,0,1,0,0.982154f,0,-0.188077f));
TEST("Matrix3 set rotate", m3c, Matrix3(-0.981005f,-0.193984f,0,0.193984f,-0.981005f,0,0,0,1));
TEST("Matrix4 set rotate", m4a, Matrix4(1,0,0,0,0,-0.210796f,-0.97753f,0,0,0.97753f,-0.210796f,0,0,0,0,1));
TEST("Matrix4 set rotate", m4b, Matrix4(-0.856889f,0,0.515501f,0,0,1,0,0,-0.515501f,0,-0.856889f,0,0,0,0,1));
TEST("Matrix4 set rotate", m4c, Matrix4(0.751806f,0.659385f,0,0,-0.659385f,0.751806f,0,0,0,0,1,0,0,0,0,1));
// vector transform
v2a = Vector2(13.5f, -48.23f);
v2c = m2 * v2a;
v3a = Vector3(13.5f, -48.23f, 862);
v3b = m3b * v3a;
v3c = m3c * v3a;
v4a = Vector4(13.5f, -48.23f, 862, 0);
Vector4 v4d = Vector4(13.5f, -48.23f, -54, 1);
v4b = m4b * v4a;
v4c = m4c * v4a;
TEST("Vector2 matrix transform", v2c, Vector2(-49.6176567078f, -6.81697654724f));
TEST("Vector3 matrix transform", v3b, Vector3(844.077941895f, -48.2299995422f, -175.38130188f));
TEST("Vector3 matrix transform", v3c, Vector3(-22.5994224548f, 44.6950683594f, 862));
TEST("Vector4 matrix transform", v4b, Vector4(-455.930236816f, -48.2299995422f, -731.678771973f, 0));
TEST("Vector4 matrix transform", v4c, Vector4(41.951499939f, -27.3578968048f, 862, 0));
// matrix multiply
Matrix2 m2b, m2c;
m2b.setRotateZ(-2.145f);
m2c = m2 * m2b;
m3d = m3a * m3c;
m4d = m4c * m4b;
TEST("Matrix2 multiply", m2c, Matrix2(-0.757975637913f, 0.652282953262f, -0.652282953262f, -0.757975637913f));
TEST("Matrix3 multiply", m3d, Matrix3(-0.981004655361f, 0.129707172513f, 0.14424264431f, 0.193984255195f, 0.655946731567f, 0.729454636574f, 0, 0.743579149246f, -0.668647944927f));
TEST("Matrix4 multiply", m4d, Matrix4(-0.644213855267f, -0.565019249916f, 0.515501439571f, 0, -0.659384667873f, 0.751805722713f, 0, 0, -0.387556940317f, -0.339913755655f, -0.856888711452f, 0, 0, 0, 0, 1));
return true;
}
