C++ (Cpp) __VERIFIER_nondet_float Beispiele

Beispiel #1

Datei: fdimf.c Projekt: smackers/smack

int main(void) {
  float NaN = 0.0f / 0.0f;
  float Inf = 1.0f / 0.0f;
  float negInf = -1.0f / 0.0f;

  float x = __VERIFIER_nondet_float();
  float y = __VERIFIER_nondet_float();

  if (!__isnanf(x) && !__isinff(x)) {
    if (!__isnanf(y) && !__isinff(y)) {
      float dim = fdimf(x, y);
      if (x > y) {
        assert(dim == x - y);
      } else {
        assert(dim == 0.0f);
      }
    }
  }

  if (!__isnanf(x)) {
    assert(fdimf(x, Inf) == 0.0f);
  }

  if (!__isnanf(y) && y < 0) {
    assert(fdimf(Inf, y) == Inf);
  }

  assert(__isnanf(fdimf(x, NaN)));
  assert(__isnanf(fdimf(NaN, y)));

  return 0;
}

Beispiel #2

Datei: float20.c Projekt: kfriedberger/sv-benchmarks

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

Beispiel #3

Datei: filter2_alt.c Projekt: graydon/sv-benchmarks

float RANDOM_INPUT()
{
  float x;
  x = __VERIFIER_nondet_float();
  __VERIFIER_assume(x >= -10.f && x <= 10.f);
  return x;
}

Beispiel #4

Datei: floorf.c Projekt: smackers/smack

int main(void) {
  float NaN = 0.0f / 0.0f;
  float Inf = 1.0f / 0.0f;
  float negInf = -1.0f / 0.0f;

  assert(floorf(2.9f) == 2.0f);

  float val = __VERIFIER_nondet_float();

  if (!__isnanf(val) && !__isinff(val) && !__iszerof(val)) {
    assert(floorf(val) <= val);
    assert(floorf(val) >= val - 1);
  }

  assert(floorf(0.0f) == 0.0f);
  assert(floorf(-0.0f) == -0.0f);
  int isNeg = __signbitf(floorf(-0.0f));
  assert(isNeg);

  assert(floorf(Inf) == Inf);
  assert(floorf(negInf) == negInf);

  assert(__isnanf(floorf(NaN)));

  return 0;
}

Beispiel #5

Datei: nan_float_range_true-unreach-call.c Projekt: xlauko/sv-benchmarks

void main()
{
  float x;
  x = __VERIFIER_nondet_float();  

  if (x >= -1e10 && x <= 1e10) {
    __VERIFIER_assert(x==x);
  }
}

Beispiel #6

Datei: testOctFloatIntervalConstraints1_false-unreach-label.c Projekt: SunshineAllWay/CPAchecker

int main(void) {
  float a = __VERIFIER_nondet_float(); //interval from -infinity to infinity

  if (a < 0) {
    return 0;
  }

  // interval from 0 to infinity 

  __VERIFIER_assert(a > 0); 

  return a;
}

Beispiel #7

Datei: sine_5.c Projekt: Heizmann/sv-benchmarks

int main()
{
  float IN = __VERIFIER_nondet_float();
  __VERIFIER_assume(IN > -HALFPI && IN < HALFPI);

  float x = IN;
  
  float result = x - (x*x*x)/6.0f + (x*x*x*x*x)/120.0f + (x*x*x*x*x*x*x)/5040.0f;

  if(!(result <= VAL && result >= -VAL))
    __VERIFIER_error();
  
  return 0;
}

Beispiel #8

Datei: inv_square_false-unreach-call.c Projekt: mchalupa/sv-benchmarks

int main()
{
  float x, y, z;

  x = __VERIFIER_nondet_float();
  __VERIFIER_assume(x >= -1.f && x <= 1.f);

  if (x != 0.f) {
    y = x * x;
    __VERIFIER_assert(y != 0.f);
    z = 1.f / y;
  }
  return 0;
}

Beispiel #9

Datei: square_3.c Projekt: kfriedberger/sv-benchmarks

int main()
{
  float IN = __VERIFIER_nondet_float();
  __VERIFIER_assume(IN >= 0.0f && IN < 1.0f);

  float x = IN;
  
  float result = 
    1.0f + 0.5f*x - 0.125f*x*x + 0.0625f*x*x*x - 0.0390625f*x*x*x*x;

  if(!(result >= 0.0f && result < VAL))
    __VERIFIER_error();
  
  return 0;
}

Beispiel #10

Datei: newton_2_5.c Projekt: Heizmann/sv-benchmarks

int main()
{
  float IN = __VERIFIER_nondet_float();
  __VERIFIER_assume(IN > -VAL && IN < VAL);

  float x = IN - f(IN)/fp(IN);
#if ITERATIONS > 1 
  x = x - f(x)/fp(x);
#if ITERATIONS > 2
  x = x - f(x)/fp(x);
#endif 
#endif

  if(!(x < 0.1))
    __VERIFIER_error();

  return 0;
}

Beispiel #11

Datei: rlim_invariant.c.p+cfa-reducer.c Projekt: kfriedberger/sv-benchmarks

 int main()
 {
 float main__X;
 float main__Y;
 float main__S;
 float main__R;
 float main__D;
 int main__i;
 main__Y = 0;
 main__i = 0;
 label_83:; 
 if (main__i < 100000)
 {
 main__X = __VERIFIER_nondet_float();
 main__D = __VERIFIER_nondet_float();
 int main____CPAchecker_TMP_0;
 if (main__X >= -128.0)
 {
 if (main__X <= 128.0)
 {
 main____CPAchecker_TMP_0 = 1;
 label_91:; 
 if (main____CPAchecker_TMP_0 != 0)
 {
 int main____CPAchecker_TMP_1;
 if (main__D >= 0.0)
 {
 if (main__D <= 16.0)
 {
 main____CPAchecker_TMP_1 = 1;
 label_98:; 
 if (main____CPAchecker_TMP_1 != 0)
 {
 main__S = main__Y;
 main__Y = main__X;
 main__R = main__X - main__S;
 if (main__R <= (-main__D))
 {
 main__Y = main__S - main__D;
 label_109:; 
 int main____CPAchecker_TMP_2;
 if (main__Y >= -129.0)
 {
 if (main__Y <= 129.0)
 {
 main____CPAchecker_TMP_2 = 1;
 label_115:; 
 {
 int __tmp_1;
 __tmp_1 = main____CPAchecker_TMP_2;
 int __VERIFIER_assert__cond;
 __VERIFIER_assert__cond = __tmp_1;
 if (__VERIFIER_assert__cond == 0)
 {
 __VERIFIER_error();
 return __return_main;
 }
 else 
 {
 main__i = main__i + 1;
 goto label_83;
 }
 }
 }
 else 
 {
 label_113:; 
 main____CPAchecker_TMP_2 = 0;
 goto label_115;
 }
 }
 else 
 {
 goto label_113;
 }
 }
 else 
 {
 if (main__R >= main__D)
 {
 main__Y = main__S + main__D;
 goto label_109;
 }
 else 
 {
 goto label_109;
 }
 }
 }
 else 
 {
 return __return_main;
 }
 }
 else 
 {
 label_96:; 
 main____CPAchecker_TMP_1 = 0;
 goto label_98;
 }
 }
 else 
 {
 goto label_96;
 }
 }
 else 
 {
 return __return_main;
 }
 }
 else 
 {
 label_89:; 
 main____CPAchecker_TMP_0 = 0;
 goto label_91;
 }
 }
 else 
 {
 goto label_89;
 }
 }
 else 
 {
 return __return_main;
 }
 }