static inline void sub(EcT& R, const EcT& P, const EcT& Q)
{
#if 0
if (P.inf_) { neg(R, Q); return; }
if (Q.inf_) { R = P; return; }
if (P.y == Q.y) { R.clear(); return; }
Fp t;
Fp::sub(t, Q.x, P.x);
if (t.isZero()) {
dbl(R, P, false);
return;
}
Fp s;
Fp::add(s, Q.y, P.y);
Fp::neg(s, s);
Fp::div(t, s, t);
R.inf_ = false;
Fp x3;
Fp::mul(x3, t, t);
x3 -= P.x;
x3 -= Q.x;
Fp::sub(s, P.x, x3);
s *= t;
Fp::sub(R.y, s, P.y);
R.x = x3;
#else
EcT nQ;
neg(nQ, Q);
add(R, P, nQ);
#endif
}
//==============================================================================
static void
interval_orientation4d(const double* x0,
const double* x1,
const double* x2,
const double* x3,
const double* x4,
double* lower,
double* upper)
{
double lower1234, upper1234;
interval_orientation3d(x1+1, x2+1, x3+1, x4+1, &lower1234, &upper1234);
double lower0234, upper0234;
interval_orientation3d(x0+1, x2+1, x3+1, x4+1, &lower0234, &upper0234);
double lower0134, upper0134;
interval_orientation3d(x0+1, x1+1, x3+1, x4+1, &lower0134, &upper0134);
double lower0124, upper0124;
interval_orientation3d(x0+1, x1+1, x2+1, x4+1, &lower0124, &upper0124);
double lower0123, upper0123;
interval_orientation3d(x0+1, x1+1, x2+1, x3+1, &lower0123, &upper0123);
fesetround(FE_DOWNWARD);
*lower= x0[0]*(x0[0]<0 ? upper1234 : lower1234)
+neg(x1[0])*(x1[0]>0 ? upper0234 : lower0234)
+x2[0]*(x2[0]<0 ? upper0134 : lower0134)
+neg(x3[0])*(x3[0]>0 ? upper0124 : lower0124)
+x4[0]*(x4[0]<0 ? upper0123 : lower0123);
fesetround(FE_UPWARD);
*upper= x0[0]*(x0[0]>0 ? upper1234 : lower1234)
+neg(x1[0])*(x1[0]<0 ? upper0234 : lower0234)
+x2[0]*(x2[0]>0 ? upper0134 : lower0134)
+neg(x3[0])*(x3[0]<0 ? upper0124 : lower0124)
+x4[0]*(x4[0]>0 ? upper0123 : lower0123);
assert(*lower<=*upper);
}
Foam::tmp<Foam::volScalarField> Foam::dragModels::GidaspowErgunWenYu::K
(
const volScalarField& Ur
) const
{
volScalarField alpha2(max(scalar(1) - alpha1_, scalar(1.0e-6)));
volScalarField d(phase1_.d());
volScalarField bp(pow(alpha2, -2.65));
volScalarField Re(max(Ur*d/phase2_.nu(), scalar(1.0e-3)));
volScalarField Cds
(
neg(Re - 1000)*(24.0*(1.0 + 0.15*pow(Re, 0.687))/Re)
+ pos(Re - 1000)*0.44
);
// Wen and Yu (1966)
return
(
pos(alpha2 - 0.8)
*(0.75*Cds*phase2_.rho()*Ur*bp/d)
+ neg(alpha2 - 0.8)
*(
150.0*alpha1_*phase2_.nu()*phase2_.rho()/(sqr(alpha2*d))
+ 1.75*phase2_.rho()*Ur/(alpha2*d)
)
);
}
Foam::tmp<Foam::volScalarField> Foam::GidaspowErgunWenYu::K
(
const volScalarField& Ur
) const
{
volScalarField beta(max(scalar(1) - alpha_, scalar(1.0e-6)));
volScalarField bp(pow(beta, -2.65));
volScalarField Re(max(Ur*phasea_.d()/phaseb_.nu(), scalar(1.0e-3)));
volScalarField Cds
(
neg(Re - 1000)*(24.0*(1.0 + 0.15*pow(Re, 0.687))/Re)
+ pos(Re - 1000)*0.44
);
// Wen and Yu (1966)
return
(
pos(beta - 0.8)
*(0.75*Cds*phaseb_.rho()*Ur*bp/phasea_.d())
+ neg(beta - 0.8)
*(
150.0*alpha_*phaseb_.nu()*phaseb_.rho()/(sqr(beta*phasea_.d()))
+ 1.75*phaseb_.rho()*Ur/(beta*phasea_.d())
)
);
}
Foam::tmp<Foam::volVectorField>
Foam::wallLubricationModels::TomiyamaWallLubrication::Fi() const
{
volVectorField Ur(pair_.Ur());
const volVectorField& n(nWall());
const volScalarField& y(yWall());
volScalarField Eo(pair_.Eo());
return
(
pos(Eo - 1.0)*neg(Eo - 5.0)*exp(-0.933*Eo + 0.179)
+ pos(Eo - 5.0)*neg(Eo - 33.0)*(0.00599*Eo - 0.0187)
+ pos(Eo - 33.0)*0.179
)
*0.5
*pair_.dispersed().d()
*(
1/sqr(y)
- 1/sqr(D_ - y)
)
*pair_.continuous().rho()
*magSqr(Ur - (Ur & n)*n)
*n;
}
Int64 Int64_multi (Int64 left, Int64 right)
{
int s = sign(right);
Int64 bin;
int i;
if (s == 0)
{
left.hi = left.low = 0;
return left;
}
else if (sign(left) == 0)
return left;
if (s < 0)
right = neg(right);
if (sign(left) < 0)
{
bin = neg(left);
s = -s;
}
else
bin = left;
left.hi = left.low = 0;
for (i = 0; i < 32; ++i, right.low >>= 1, bin = Int64_plus(bin, bin))
if ((right.low & 1) != 0)
left = Int64_plus(left, bin);
for (i = 0; i < 32; ++i, right.hi >>= 1, bin = Int64_plus(bin, bin))
if ((right.hi & 1) != 0)
left = Int64_plus(left, bin);
if (s < 0)
left = neg(left);
return left;
}
int main()
{
std::cout << "neg(10) " << neg (10) << std::endl;
std::cout << "neg(-0.1) " << neg (-0.1) << std::endl;
std::cout << "neg(11000) " << neg (11000) << std::endl;
return 0;
}
int search_large(unsigned char *x, int m, unsigned char *y, int n) {
unsigned int D, B[SIGMA], NEG0, NEG0m1;
int i,j,k,count, first, p_len;
p_len = m;
m = 32;
/* Preprocessing */
BEGIN_PREPROCESSING
for(i=0; i<SIGMA; i++) B[i] = neg(0);
for(j=0; j<m; j++) B[x[j]] = B[x[j]] & neg((1<<j));
NEG0 = neg(0);
NEG0m1 = neg(0)<<(m-1);
END_PREPROCESSING
/* searching */
BEGIN_SEARCHING
count = 0;
i = m-1;
while( i < n ) {
D = B[y[i]];
while (D != NEG0) {
if (D < NEG0m1) {
k = 0; first=i-m+1;
while(k<p_len && x[k]==y[first+k]) k++;
if (k==p_len && i<n) count++;
}
i = i+1;
D = (D<<1) | B[y[i]];
}
i=i+m;
}
END_SEARCHING
return count;
}
static bool isOK_setFormatForOneNumber(void) {
OutputFormat format;
nameString result[2] = { "%- 10.5lg", "% 10.5lg" };
format.leftJustified = true;
format.precision = 5;
format.width = 10;
for (short i = 0; i < 2; i++, neg(&format.leftJustified)) {
SAVE_FUNCTION_CALLER();
setFormatForOneNumber(&format);
if (strcmp(result[i], format.oneNumber)) {
PRINT_ERROR();
return false;
}
}
format.leftJustified = false;
for (short i = 0; i < 2; i++, neg(&format.leftJustified)) {
SAVE_FUNCTION_CALLER();
setFormatForOneNumber(&format);
if (!strcmp(result[i], format.oneNumber)) {
PRINT_ERROR();
return false;
}
}
PRINT_OK();
return true;
}
BigInt BigInt::operator-=(const BigInt& second)
{
neg();
(*this) += second;
neg();
return *this;
}
scfx_rep*
scfx_pow10::neg( int i )
{
if( ! m_neg[i].is_normal() )
{
multiply( m_neg[i], *neg( i - 1 ), *neg( i - 1 ) );
}
return &m_neg[i];
}
//==============================================================================
static double
simple_orientation2d(const double* x0,
const double* x1,
const double* x2)
{
return x0[0]*x1[1] + neg(x0[0])*x2[1]
+ x1[0]*x2[1] + neg(x1[0])*x0[1]
+ x2[0]*x0[1] + neg(x2[0])*x1[1];
}
literalt aig_prop_baset::lor(const bvt &bv)
{
literalt literal=const_literal(true);
// Introduces N-1 extra nodes for N bits
// See convert_node for where this overhead is removed
forall_literals(it, bv)
literal=land(neg(*it), literal);
return neg(literal);
}
void aig_prop_baset::set_equal(literalt a, literalt b)
{
#ifdef USE_AIG_COMPACT
// The compact encoding should reduce this
l_set_to_true(lequal(a,b));
#else
// we produce two constraints:
// a|!b !a|b
l_set_to_true(lor(pos(a), neg(b)));
l_set_to_true(lor(neg(a), pos(b)));
#endif
}
char *ft_addsubstr(char *a, char *b, int op)
{
char *abs_a;
char *abs_b;
char *ret;
abs_a = absolute(a);
abs_b = absolute(b);
ret = NULL;
if (op == 1)
{
ret = (neg(a) && neg(b)) ? operation(abs_a, abs_b, 1, 1) : ret;
if ((neg(a) && !neg(b)) || (!neg(a) && neg(b)))
{
if (ft_strcmp(abs_a, abs_b) >= 0)
ret = operation(abs_a, abs_b, 0, -1);
else
ret = operation(abs_a, abs_b, 1, -1);
}
ret = (!neg(a) && !neg(b)) ? operation(abs_a, abs_b, 0, 1) : ret;
}
else
ret = addsubstr_next(a, b, abs_a, abs_b);
ft_strdel(&abs_a);
ft_strdel(&abs_b);
return (ret);
}
literalt aig_prop_baset::lxor(literalt a, literalt b)
{
if(a.is_false()) return b;
if(b.is_false()) return a;
if(a.is_true()) return neg(b);
if(b.is_true()) return neg(a);
if(a==b) return const_literal(false);
if(a==neg(b)) return const_literal(true);
// This produces up to three nodes!
// See convert_node for where this overhead is removed
return lor(land(a, neg(b)), land(neg(a), b));
}
void TestRefractionExtinction::testBase()
{
RefractionExtinction refExt;
Vec3d v(1.,0.,0.);
float mag=4.f;
refExt.forward(&v, &mag, 1);
QVERIFY(mag>=4.);
QVERIFY(v[2]>=0);
Vec3d vert(0.,0.,1.);
mag=2.0f;
refExt.setExtinctionCoefficient(0.25);
refExt.setTemperature(15.0);
refExt.setPressure(1000.0);
refExt.forward(&vert, &mag, 1);
QVERIFY(mag==2.25);
QVERIFY(vert[2]==1.0);
Vec3d neg(std::sqrt(2.0),0.,std::sqrt(2.0));
mag=2.0f;
refExt.forward(&neg, &mag, 1);
QVERIFY(mag==2.0);
QVERIFY(neg[2]==std::sqrt(2.0));
}
char enum_BBconflictInPath( branch *bru, char direction, block *bv,
ushort *bb_seq, ushort len, block **bblist, int num_bb ) {
int cf, id, idx;
char res;
branch *br;
// check for each branch conflicting with bru, whether it occurs in this path
for( cf = 0; cf < bru->num_conflicts; cf++ ) {
br = bru->conflicts[cf];
id = enum_findBranch( br, bb_seq, len );
if( id == -1 )
continue;
idx = getblock( bb_seq[id-1], bblist, 0, num_bb-1 );
if( idx == -1 )
continue;
// direction taken by br to its successor in bb_seq
res = detectDirection( br, bblist[idx] );
if( ( direction == bru->jump_cond && bru->conflictdir_jump[cf] == res ) ||
( direction == neg( bru->jump_cond ) && bru->conflictdir_fall[cf] == res ) ) {
// check cancellation of effect by assignment
id = enum_effectCancelled( br, NULL, bb_seq, len, bblist, num_bb );
if( id == -1 ) {
return 1;
}
}
}
return 0;
}
literalt cnft::land(const bvt &bv)
{
if(bv.size()==0) return const_literal(true);
if(bv.size()==1) return bv[0];
if(bv.size()==2) return land(bv[0], bv[1]);
forall_literals(it, bv)
if(it->is_false())
return *it;
if(is_all(bv, const_literal(true)))
return const_literal(true);
bvt new_bv;
eliminate_duplicates(bv, new_bv);
bvt lits(2);
literalt literal=new_variable();
lits[1]=neg(literal);
forall_literals(it, new_bv)
{
lits[0]=pos(*it);
lcnf(lits);
}
void StrPrinter::bvisit(const Mul &x) {
std::ostringstream o, o2;
bool num = false;
unsigned den = 0;
std::map<RCP<const Basic>, RCP<const Basic>,
RCPBasicKeyLessCmp> dict(x.dict_.begin(), x.dict_.end());
if (eq(*(x.coef_), *minus_one)) {
o << "-";
} else if (neq(*(x.coef_), *one)) {
o << parenthesizeLT(x.coef_, PrecedenceEnum::Mul) << "*";
num = true;
}
for (auto &p: dict) {
if ((is_a<Integer>(*p.second) &&
rcp_static_cast<const Integer>(p.second)->is_negative()) ||
(is_a<Rational>(*p.second) &&
rcp_static_cast<const Rational>(p.second)->is_negative())) {
if(eq(*(p.second), *minus_one)) {
o2 << parenthesizeLT(p.first, PrecedenceEnum::Mul);
} else {
o2 << parenthesizeLE(p.first, PrecedenceEnum::Pow);
o2 << "**";
o2 << parenthesizeLE(neg(p.second), PrecedenceEnum::Pow);
}
o2 << "*";
den++;
} else {
if(eq(*(p.second), *one)) {
o << parenthesizeLT(p.first, PrecedenceEnum::Mul);
} else {
o << parenthesizeLE(p.first, PrecedenceEnum::Pow);
o << "**";
o << parenthesizeLE(p.second, PrecedenceEnum::Pow);
}
o << "*";
num = true;
}
}
if (!num) {
o << "1*";
}
std::string s = o.str();
s = s.substr(0, s.size() - 1);
if (den != 0) {
std::string s2 = o2.str();
s2 = s2.substr(0, s2.size() - 1);
if (den > 1) {
str_ = s + "/(" + s2 + ")";
} else {
str_ = s + "/" + s2;
}
} else {
str_ = s;
}
}
bool doc_manager::fold_neg(doc& dst) {
start_over:
for (unsigned i = 0; i < dst.neg().size(); ++i) {
if (m.contains(dst.neg()[i], dst.pos()))
return false;
unsigned index;
unsigned count = diff_by_012(dst.pos(), dst.neg()[i], index);
if (count != 2) {
if (count == 0) {
return false;
}
else if (count == 3) {
dst.neg().erase(tbvm(), i);
--i;
}
else { // count == 1:
m.set(dst.pos(), index, neg(dst.neg()[i][index]));
dst.neg().intersect(tbvm(), dst.pos());
goto start_over;
}
}
}
SASSERT(well_formed(dst));
return true;
}
int mainProfileReflect(int argc, char* argv[]) {
if ( argc != 3 ) {
printf("Usage: %s inGrid externalForce\n", argv[0]);
return 0;
}
double externalForce = strtod(argv[2], NULL);
char outNeg[256];
char outPos[256];
sprintf(outNeg, "%s.neg.dat", argv[1]);
sprintf(outPos, "%s.pos.dat", argv[1]);
Grid pos(argv[1]);
Grid neg(pos);
Vector3 force(0.0, 0.0, -externalForce);
double v0;
pos.addGradient(force);
v0 = pos.getValue(0);
pos.shift(-v0);
neg.flipZ();
neg.addGradient(force);
v0 = pos.getValue(0);
neg.shift(-v0);
pos.averageProfileZBoltzmann(outPos);
neg.averageProfileZBoltzmann(outNeg);
}
/* task that renders a single screen tile */
Vec3fa renderPixelStandard(float x, float y, const ISPCCamera& camera, RayStats& stats)
{
/* initialize ray */
Ray ray(Vec3fa(camera.xfm.p), Vec3fa(normalize(x*camera.xfm.l.vx + y*camera.xfm.l.vy + camera.xfm.l.vz)), 0.0f, inf);
/* intersect ray with scene */
RTCIntersectContext context;
rtcInitIntersectContext(&context);
rtcIntersect1(g_scene,&context,RTCRayHit_(ray));
RayStats_addRay(stats);
/* shade pixels */
Vec3fa color = Vec3fa(0.0f);
if (ray.geomID != RTC_INVALID_GEOMETRY_ID)
{
Vec3fa diffuse = colors[ray.geomID];
color = color + diffuse*0.1f;
Vec3fa lightDir = normalize(Vec3fa(-1,-1,-1));
/* initialize shadow ray */
Ray shadow(ray.org + ray.tfar*ray.dir, neg(lightDir), 0.001f, inf);
/* trace shadow ray */
rtcOccluded1(g_scene,&context,RTCRay_(shadow));
RayStats_addShadowRay(stats);
/* add light contribution */
if (shadow.tfar >= 0.0f)
color = color + diffuse*clamp(-dot(lightDir,normalize(ray.Ng)),0.0f,1.0f);
}
return color;
}
tmp<volScalarField> SpalartAllmarasIDDES::dTilda(const volScalarField& S) const
{
volScalarField alpha = this->alpha();
volScalarField expTerm = exp(sqr(alpha));
volScalarField fHill =
2*(pos(alpha)*pow(expTerm, -11.09) + neg(alpha)*pow(expTerm, -9.0));
volScalarField fStep = min(2*pow(expTerm, -9.0), scalar(1));
volScalarField fHyb = max(1 - fd(S), fStep);
volScalarField fAmp = 1 - max(ft(S), fl(S));
volScalarField fRestore = max(fHill - 1, scalar(0))*fAmp;
// IGNORING ft2 terms
volScalarField Psi = sqrt
(
min
(
scalar(100),
(1 - Cb1_/(Cw1_*sqr(kappa_)*fwStar_)*fv2())/max(SMALL, fv1())
)
);
return max
(
dimensionedScalar("SMALL", dimLength, SMALL),
fHyb*(1 + fRestore*Psi)*y_
+ (1 - fHyb)*CDES_*Psi*delta()
);
}
static int read_raw(const PIXF_Info *info, void *imgbytes, size_t hsize)
{
unsigned char *iptr = (unsigned char *)imgbytes;
size_t i, n;
for (i = 0; i < info->height; i++) {
n = fread(iptr, 1, hsize, info->f);
if (n < hsize) {
#ifdef PIXF_ENABLE_VERBOSE
if (pixf_verbose)
fprintf(stderr, "%s: unexpected EOF during reading of image data (expected %lu bytes, read %lu)\n",
__func__, (unsigned long)hsize, (unsigned long)n);
#endif
return PIXF_ERR_READ;
}
/* if we are running on little-endian machine and sample size is
more than 8 bits (aligned to 16 bits), swap bytes */
#if __BYTE_ORDER==__LITTLE_ENDIAN
if (info->bps>8) swap_b(iptr,hsize);
#endif
if (info->bpp == 1) neg((void *)iptr,hsize);
iptr += hsize;
}
return PIXF_ERR_OK;
}
int count_negs(char *input, int *start, const int mode) {
int negs = 0;
int last_sign = POS;
while (input[*start] != 0) {
if (input[*start] == '(') {
(*start)++;
negs += count_negs(input, start, mode);
}
if (input[*start] == '-') {
if (input[*start + 1] == '(') {
*start = *start + 2;
negs += count_negs(input, start, mode ^ 1);
continue;
}
last_sign = NEG;
(*start)++;
}
if (input[*start] == '+') {
last_sign = POS;
(*start)++;
}
if (input[*start] == 'x') {
negs += neg(last_sign, mode);
(*start)++;
}
if (input[*start] == ')') {
(*start)++;
return negs;
}
}
return negs;
}
int detectDirection( branch *bru, block *bv ) {
if( bru->bb->outgoing[1] == bv->bbid )
return bru->jump_cond;
else
return neg( bru->jump_cond );
/*
char *jumpdest;
instr *insn;
// If bru's jump dest. == start address of bv,
// then direction( bru, bv ) == bru's jump condition, otherwise the negation.
insn = bru->bb->instrlist[ bru->bb->num_instr - 1 ];
jumpdest = getJumpDest( insn );
// printf( "dest: %s jumpdest: %s jumpdir: %d\n", bv->instrlist[0]->addr, jumpdest, jumpdir );
if( jumpdest == NULL )
return NA;
if( strcmp( bv->instrlist[0]->addr, jumpdest ) == 0 )
return bru->jump_cond;
else
return neg( bru->jump_cond );
*/
}
static zword find_word(zword dictionarytable, const char *word, int length)
{
zbyte zsciibuffer[12];
int entry_length, word_length;
int num_entries;
void *p;
entry_length = LOBYTE(dictionarytable);
dictionarytable++;
num_entries = LOWORD(dictionarytable);
dictionarytable+=ZWORD_SIZE;
if(zversion <= 3)
word_length = 4;
else
word_length = 6;
encodezscii(zsciibuffer, word_length, word_length, word, length);
dictentry_len = word_length;
if(is_neg(num_entries)) { /* Unordered dictionary */
num_entries = neg(num_entries);
p = n_lfind(zsciibuffer, z_memory + dictionarytable, &num_entries,
entry_length, cmpdictentry);
} else { /* Ordered dictionary */
p = n_bsearch(zsciibuffer, z_memory + dictionarytable, num_entries,
entry_length, cmpdictentry);
}
if(p)
return ((zbyte *) p) - z_memory;
return 0;
}
void mpq_manager<SYNCH>::display_decimal(std::ostream & out, mpq const & a, unsigned prec) {
mpz n1, d1, v1;
get_numerator(a, n1);
get_denominator(a, d1);
if (is_neg(a)) {
out << "-";
neg(n1);
}
mpz ten(10);
div(n1, d1, v1);
display(out, v1);
rem(n1, d1, n1);
if (is_zero(n1))
goto end; // number is an integer
out << ".";
for (unsigned i = 0; i < prec; i++) {
mul(n1, ten, n1);
div(n1, d1, v1);
SASSERT(lt(v1, ten));
display(out, v1);
rem(n1, d1, n1);
if (is_zero(n1))
goto end; // number is precise
}
out << "?";
end:
del(ten); del(n1); del(d1); del(v1);
}
char BBconflictInPath( branch *bru, char direction, block *bv, path *pv, block **bblist, int num_bb )
{
int cf, id;
char res;
branch *br;
// check for each branch conflicting with bru, whether it occurs in this path
for( cf = 0; cf < bru->num_conflicts; cf++ ) {
br = bru->conflicts[cf];
id = findBranch( br, pv->branch_eff, pv->branch_len );
if( id == -1 )
continue;
res = pv->branch_dir[id];
if( ( direction == bru->jump_cond && bru->conflictdir_jump[cf] == res ) ||
( direction == neg( bru->jump_cond ) && bru->conflictdir_fall[cf] == res ) ) {
// check cancellation of effect by assignment
id = effectCancelled( br, NULL, pv, bblist, num_bb );
if( id == -1 ) {
return 1;
}
}
}
return 0;
}
