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.); }