int main()
{
double a, r;
a = __VERIFIER_nondet_double();
__VERIFIER_assume(a >= -1e10 && a <= 1e10);
r = SIN(a);
return 0;
}
int main (void) {
float f=__VERIFIER_nondet_float();
bug(f);
float g=__VERIFIER_nondet_float();
bugBrokenOut(g);
double d=__VERIFIER_nondet_double();
bugCasting(d);
return 1;
}
int main()
{
double d, r;
d = __VERIFIER_nondet_double();
__VERIFIER_assume(d >= 0.1 && d <= 20.0);
r = SqrtR(d);
__VERIFIER_assert(r >= 0.3 && r <= 5.);
return 0;
}
int main()
{
double a, r;
a = __VERIFIER_nondet_double();
__VERIFIER_assume(a >= -1.79e308 && a <= 1.79e308);
r = ARCTAN(a);
__VERIFIER_assert(r >= -1.571 && r <= 1.571);
return 0;
}
int main(void)
{
double d = __VERIFIER_nondet_double();
__VERIFIER_assume(!isinf(d));
__VERIFIER_assume(!isnan(d));
__VERIFIER_assume(d < LLONG_MAX && d > LLONG_MIN);
double d1 = (long long) d;
__VERIFIER_assert(trunc(d) == d1);
return 0;
}
void main()
{
double x,y;
x = __VERIFIER_nondet_double();
__VERIFIER_assume(x >= 0. && x <= 10.);
y = x*x - x;
if (y >= 0) y = x / 10.;
else y = x*x + 2.;
__VERIFIER_assert(y >= 0. && y <= 4.);
}
int main(void)
{
double d = __VERIFIER_nondet_double();
__VERIFIER_assume(!isinf(d));
__VERIFIER_assume(!isnan(d));
int save_round = fegetround();
fesetround(FE_TOWARDZERO);
double result = rint(d);
fesetround(save_round);
__VERIFIER_assert(trunc(d) == result);
double d1 = __VERIFIER_nondet_double();
__VERIFIER_assume(isinf(d1));
__VERIFIER_assert(isinf(trunc(d1)));
double d2 = __VERIFIER_nondet_double();
__VERIFIER_assume(isinf(d2));
__VERIFIER_assert(isinf(trunc(d2)));
return 0;
}
int main() {
double x = __VERIFIER_nondet_double();
if (x >= 0.0) {
while (__VERIFIER_nondet_int()) {
x = x + 1.0;
}
x = x + 1.0;
while (__VERIFIER_nondet_int()) {
x = x + 1.0;
}
//@ assert x > 0.0;
}
return 0;
}
int main()
{
double d, dd, r;
double epsilon = 1e-8;
for (d = 1.; d <= 20.; d++) {
dd = __VERIFIER_nondet_double();
__VERIFIER_assume(dd >= d-epsilon && dd <= d+epsilon);
r = SqrtR(dd);
__VERIFIER_assert(r >= 0.9 && r <= 5.);
}
return 0;
}
int main()
{
double a = __VERIFIER_nondet_double();
__VERIFIER_assume(!__isnan(a));
__VERIFIER_assume(!__isinf(a));
__VERIFIER_assume(a != 0.0);
double plus_zero = 0.0;
double plus_zero_mod = fmod(plus_zero, a);
_Bool plus_zero_mod_sign = __signbit(plus_zero);
__VERIFIER_assert((plus_zero_mod == 0.0) && !plus_zero_mod_sign);
double minus_zero = -0.0;
double minus_zero_mod = fmod(minus_zero, a);
_Bool minus_zero_mod_sign = signbit(minus_zero);
__VERIFIER_assert((minus_zero_mod == 0.0) && minus_zero_mod_sign);
return 0;
}
void main()
{
double E, E0, E1, S0, S1, S;
double A1, A2, A3, B1, B2;
int i;
A1 = __VERIFIER_nondet_double();
A2 = __VERIFIER_nondet_double();
A3 = __VERIFIER_nondet_double();
B1 = __VERIFIER_nondet_double();
B2 = __VERIFIER_nondet_double();
__VERIFIER_assume(A1 >= 0.69 && A1 <= 0.71);
__VERIFIER_assume(A2 >= -1.31 && A2 <= -1.29);
__VERIFIER_assume(A3 >= 1.09 && A3 <= 1.11);
__VERIFIER_assume(B1 >= 1.39 && B1 <= 1.41);
__VERIFIER_assume(B2 >= -0.71 && B2 <= -0.69);
E = __VERIFIER_nondet_double();
E0 = __VERIFIER_nondet_double();
__VERIFIER_assume(E >= 0. && E <= 1.);
__VERIFIER_assume(E0 >= 0. && E0 <= 1.);
S0 = 0;
S = 0;
for (i = 0; i <= 1000000; i++) {
E1 = E0;
E0 = E;
E = __VERIFIER_nondet_double();
__VERIFIER_assume(E >= 0. && E <= 1.);
S1 = S0;
S0 = S;
S = A1*E - E0*A2 + E1*A3 + S0*B1 + S1*B2;
__VERIFIER_assert(S >= -100. && S <= 100.);
}
}
int main() {
/* REQ-BL-0920
* The log and logf procedures shall return NaN if the argument x is finite
* and less than 0 or x is -Inf.
*/
double x = __VERIFIER_nondet_double();
if ((x < 0 && isfinite_double(x))) {
double res = __ieee754_log(x);
// x is < 0 and finite, result shall be NAN
if (!isnan_double(res)) {
__VERIFIER_error();
return 1;
}
}
return 0;
}
int main() {
/* REQ-BL-1300
* The isfinite procedure shall return a non-zero value if the argument x has
* a finite value and is neither NaN nor +-Inf .
*/
double x = __VERIFIER_nondet_double();
// x is inf, or nan we don't want to continue
if (!isinf_double(x) && !isnan_double(x)) {
double res = isfinite_double(x);
// x is not inf, is not nan, the result shall be not 0.
if (res == 0.0) {
__VERIFIER_error();
return 1;
}
}
return 0;
}
void main()
{
double E0, E1, S;
int i;
E1 = 0;
S = 0;
for (i = 0; i <= 1000000; i++) {
E0 = __VERIFIER_nondet_double();
__VERIFIER_assume(E0 >= -1. && E0 <= 1.);
if (__VERIFIER_nondet_int()) {
S = 0;
}
else {
S = 0.999 * S + E0 - E1;
}
E1 = E0;
__VERIFIER_assert(S >= -10000. && S <= 10000.);
}
}
int main(void) {
double NaN = 0.0 / 0.0;
double Inf = 1.0 / 0.0;
double negInf = -1.0 / 0.0;
double val = __VERIFIER_nondet_double();
if (!__isnan(val) && !__isinf(val) && !__iszero(val)) {
double rval = round(val);
assert(rval == floor(val) || rval == ceil(val));
}
assert(round(0.0) == 0.0);
assert(round(-0.0) == -0.0);
int isNeg = __signbit(round(-0.0));
assert(isNeg);
assert(round(Inf) == Inf);
assert(round(negInf) == negInf);
assert(__isnan(round(NaN)));
return 0;
}
void main()
{
double xm2, xm1, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9;
double x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21;
double y0, y1, y2, y3, y4, y5, y6, y7, y8, y9;
double y10, y11, y12, y13, y14, y15, y16, y17, y18, y19;
filter(-1.0, 1.0, -1.0, 1.0, -1.0, 1.0, -1.0, 1.0, -1.0, 1.0, -1.0, 1.0, -1.0, 1.0, -1.0, 1.0, -1.0, 1.0, -1.0, 1.0,
&x1, &x2, &x3, &x4, &x5, &x6, &x7, &x8, &x9, &x10, &x11, &x12, &x13, &x14, &x15, &x16, &x17, &x18, &x19);
filter(1.0, -1.0, 1.0, -1.0, 1.0, -1.0, 1.0, -1.0, 1.0, -1.0, 1.0, -1.0, 1.0, -1.0, 1.0, -1.0, 1.0, -1.0, 1.0, -1.0,
&x1, &x2, &x3, &x4, &x5, &x6, &x7, &x8, &x9, &x10, &x11, &x12, &x13, &x14, &x15, &x16, &x17, &x18, &x19);
xm2=0;
xm1=0;
x0=0;
x1=-1;
x2=-0.5;
x3=0.75;
x4=1;
x5=1;
x6=1;
x7=1;
x8=1;
x9=1;
x10=1;
x11=1;
x12=1;
x13=1;
x14=1;
x15=1;
x16=1;
x17=1;
x18=1;
x19=1;
x20=1;
x21=1;
sobelitereen(xm2, xm1, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9,
x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21,
&y1, &y2, &y3, &y4, &y5, &y6, &y7, &y8, &y9, &y10, &y11, &y12, &y13, &y14, &y15, &y16, &y17, &y18, &y19);
x1=0;
x2=0.5;
x3=1.0;
sobelitereen(xm2, xm1, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9,
x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21,
&y1, &y2, &y3, &y4, &y5, &y6, &y7, &y8, &y9, &y10, &y11, &y12, &y13, &y14, &y15, &y16, &y17, &y18, &y19);
int i = 0;
while (i < 10) {
x1 = __VERIFIER_nondet_double();
x2 = __VERIFIER_nondet_double();
x3 = __VERIFIER_nondet_double();
__VERIFIER_assume(x1 >= -1.0 + i/10 && x1 <= -1.0 + (i+1)/10);
__VERIFIER_assume(x2 >= -.5 + i/10 && x2 <= -0.5 + (i+1)/10);
__VERIFIER_assume(x3 >= 0.75+i/40 && x3 <= 0.75+(i+1)/40);
sobelitereen(xm2, xm1, x0, x1, x2, x3, x4, x5, x6, x7, x8, x9,
x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21,
&y1, &y2, &y3, &y4, &y5, &y6, &y7, &y8, &y9, &y10, &y11, &y12, &y13, &y14, &y15, &y16, &y17, &y18, &y19);
++i;
};
__VERIFIER_assert(y1 >= -1. && y1 <= 1.);
__VERIFIER_assert(y2 >= -1. && y2 <= 1.);
__VERIFIER_assert(y3 >= -1. && y3 <= 1.);
__VERIFIER_assert(y4 >= -1. && y4 <= 1.);
__VERIFIER_assert(y5 >= -1. && y5 <= 1.);
__VERIFIER_assert(y6 >= -1. && y6 <= 1.);
__VERIFIER_assert(y7 >= -1. && y7 <= 1.);
__VERIFIER_assert(y8 >= -1. && y8 <= 1.);
__VERIFIER_assert(y9 >= -1. && y9 <= 1.);
__VERIFIER_assert(y10 >= -1. && y10 <= 1.);
__VERIFIER_assert(y11 >= -1. && y11 <= 1.);
__VERIFIER_assert(y12 >= -1. && y12 <= 1.);
__VERIFIER_assert(y13 >= -1. && y13 <= 1.);
__VERIFIER_assert(y14 >= -1. && y14 <= 1.);
__VERIFIER_assert(y15 >= -1. && y15 <= 1.);
__VERIFIER_assert(y16 >= -1. && y16 <= 1.);
__VERIFIER_assert(y17 >= -1. && y17 <= 1.);
__VERIFIER_assert(y18 >= -1. && y18 <= 1.);
__VERIFIER_assert(y19 >= -1. && y19 <= 1.);
}
