correct           117 apps/fft/main.cpp             float correct = 0;
correct           120 apps/fft/main.cpp                     correct += in((x + j + W)%W, (y + i + H)%H);
correct           123 apps/fft/main.cpp             correct /= box*box;
correct           124 apps/fft/main.cpp             if (fabs(result_c2c(x, y) - correct) > 1e-6f) {
correct           125 apps/fft/main.cpp                 printf("result_c2c(%d, %d) = %f instead of %f\n", x, y, result_c2c(x, y), correct);
correct           128 apps/fft/main.cpp             if (fabs(result_r2c(x, y) - correct) > 1e-6f) {
correct           129 apps/fft/main.cpp                 printf("result_r2c(%d, %d) = %f instead of %f\n", x, y, result_r2c(x, y), correct);
correct           357 src/CSE.cpp    void check(Expr in, Expr correct) {
correct           361 src/CSE.cpp        internal_assert(equal(result, correct))
correct           364 src/CSE.cpp            << "\ninstead of:\n" << correct << "\n";
correct           389 src/CSE.cpp        Expr e, correct;
correct           398 src/CSE.cpp        correct = ssa_block({x*x,                  // x*x
correct           402 src/CSE.cpp        check(e, correct);
correct           405 src/CSE.cpp        check(correct, correct);
correct           414 src/CSE.cpp        correct = ssa_block({x*x,
correct           417 src/CSE.cpp        check(e, correct);
correct           431 src/CSE.cpp        correct = ssa_block({x*x,                // t0 = a = x*x
correct           437 src/CSE.cpp        check(e, correct);
correct           457 src/CSE.cpp            correct = ssa_block({x*y,
correct           463 src/CSE.cpp            check(e, correct);
correct           476 src/CSE.cpp            correct = ssa_block({x*y,
correct           482 src/CSE.cpp            check(e, correct);
correct           492 src/CSE.cpp            correct = Let::make("t0", handle_b,
correct           494 src/CSE.cpp            check(e, correct);
correct            88 test/common/check_call_graphs.h             int correct = func(x, y);
correct            89 test/common/check_call_graphs.h             if (im(x, y) != correct) {
correct            91 test/common/check_call_graphs.h                        x, y, im(x, y), correct);
correct           103 test/common/check_call_graphs.h                 int correct = func(x, y, z);
correct           104 test/common/check_call_graphs.h                 if (im(x, y, z) != correct) {
correct           106 test/common/check_call_graphs.h                            x, y, z, im(x, y, z), correct);
correct            54 test/correctness/align_bounds.cpp             int correct = (i&1) == 1 ? 6 : 22;
correct            55 test/correctness/align_bounds.cpp             if (result(i) != correct) {
correct            57 test/correctness/align_bounds.cpp                        i, result(i), correct);
correct           117 test/correctness/align_bounds.cpp             int correct = (i&1) == 1 ? 6 : 22;
correct           118 test/correctness/align_bounds.cpp             if (result(i) != correct) {
correct           120 test/correctness/align_bounds.cpp                        i, result(i), correct);
correct            14 test/correctness/bad_likely.cpp         int correct = (x < 10 || x > 20) ? 1 : 2;
correct            15 test/correctness/bad_likely.cpp         if (im(x) != correct) {
correct            16 test/correctness/bad_likely.cpp             printf("im(%d) = %d instead of %d\n", x, im(x), correct);
correct            32 test/correctness/bitwise_ops.cpp         uint32_t correct = input(x) ^ input(x+1);
correct            33 test/correctness/bitwise_ops.cpp         if (im2(x) != correct) {
correct            35 test/correctness/bitwise_ops.cpp                    input(x), input(x+1), im2(x), correct);
correct            45 test/correctness/bitwise_ops.cpp         uint32_t correct = input(x) & input(x+1);
correct            46 test/correctness/bitwise_ops.cpp         if (im3(x) != correct) {
correct            48 test/correctness/bitwise_ops.cpp                    input(x), input(x+1), im3(x), correct);
correct            58 test/correctness/bitwise_ops.cpp         uint32_t correct = input(x) | input(x+1);
correct            59 test/correctness/bitwise_ops.cpp         if (im4(x) != correct) {
correct            61 test/correctness/bitwise_ops.cpp                    input(x), input(x+1), im4(x), correct);
correct            71 test/correctness/bitwise_ops.cpp         uint32_t correct = ~input(x);
correct            72 test/correctness/bitwise_ops.cpp         if (im5(x) != correct) {
correct            74 test/correctness/bitwise_ops.cpp                    input(x), im5(x), correct);
correct            84 test/correctness/bitwise_ops.cpp         uint32_t correct = input(x) << (input(x+1) & 0xf);
correct            85 test/correctness/bitwise_ops.cpp         if (im6(x) != correct) {
correct            87 test/correctness/bitwise_ops.cpp                    input(x), input(x+1), im6(x), correct);
correct            97 test/correctness/bitwise_ops.cpp         uint32_t correct = input(x) >> (input(x+1) & 0xf);
correct            98 test/correctness/bitwise_ops.cpp         if (im7(x) != correct) {
correct           100 test/correctness/bitwise_ops.cpp                    input(x), input(x+1), im7(x), correct);
correct           112 test/correctness/bitwise_ops.cpp         int correct = ((int)(input(x))) >> (((int)(input(x+1))) & 0xf);
correct           113 test/correctness/bitwise_ops.cpp         if (im8(x) != correct) {
correct           115 test/correctness/bitwise_ops.cpp                    input(x), input(x+1), im8(x), correct);
correct           131 test/correctness/bitwise_ops.cpp         int correct = lhs >> shift_amount;
correct           132 test/correctness/bitwise_ops.cpp         if (im9(x) != correct) {
correct           134 test/correctness/bitwise_ops.cpp                    input(x), input(x+1), im9(x), correct);
correct           145 test/correctness/bitwise_ops.cpp         int8_t correct = (int8_t)(input(x)) & 0xf0;
correct           146 test/correctness/bitwise_ops.cpp         if (im10(x) != correct) {
correct           148 test/correctness/bitwise_ops.cpp                    input(x), im10(x), correct);
correct            18 test/correctness/bounds_of_monotonic_math.cpp     int correct = 26;
correct            19 test/correctness/bounds_of_monotonic_math.cpp     if (in.width() != correct) {
correct            20 test/correctness/bounds_of_monotonic_math.cpp         printf("Width is %d instead of %d\n", in.width(), correct);
correct            46 test/correctness/c_function.cpp             float correct = (float)(i*j);
correct            47 test/correctness/c_function.cpp 	    float delta = imf(i, j) - correct;
correct            49 test/correctness/c_function.cpp                 printf("imf[%d, %d] = %f instead of %f\n", i, j, imf(i, j), correct);
correct            70 test/correctness/c_function.cpp             float correct = (float)(i*j);
correct            71 test/correctness/c_function.cpp 	    float delta = imf2(i, j) - correct;
correct            73 test/correctness/c_function.cpp                 printf("imf2[%d, %d] = %f instead of %f\n", i, j, imf2(i, j), correct);
correct            91 test/correctness/c_function.cpp             float correct = (float)(i*j);
correct            92 test/correctness/c_function.cpp 	    float delta = imf3(i, j) - correct;
correct            94 test/correctness/c_function.cpp                 printf("imf3[%d, %d] = %f instead of %f\n", i, j, imf3(i, j), correct);
correct            23 test/correctness/cast_handle.cpp     uint64_t correct = (uint64_t)((uintptr_t)(&foo));
correct            26 test/correctness/cast_handle.cpp         if (out1(x) != correct) {
correct            30 test/correctness/cast_handle.cpp                    (long long unsigned)correct);
correct            33 test/correctness/cast_handle.cpp         if (out2(x) != correct) {
correct            37 test/correctness/cast_handle.cpp                    (long long unsigned)correct);
correct            15 test/correctness/compare_vars.cpp             int correct = (x == y) ? 1 : 0;
correct            16 test/correctness/compare_vars.cpp             if (im(x, y) != correct) {
correct            18 test/correctness/compare_vars.cpp                        x, y, im(x, y), correct);
correct           110 test/correctness/compute_at_split_rvar.cpp             int correct = (i / 2) + ((i % 2 == 0) ? 0 : 5);
correct           111 test/correctness/compute_at_split_rvar.cpp             if (im(i) != correct) {
correct           112 test/correctness/compute_at_split_rvar.cpp                 printf("im(%d) = %d instead of %d\n", i, im(i), correct);
correct           135 test/correctness/compute_at_split_rvar.cpp             int correct = i;
correct           136 test/correctness/compute_at_split_rvar.cpp             if (im(i) != correct) {
correct           137 test/correctness/compute_at_split_rvar.cpp                 printf("im(%d) = %d instead of %d\n", i, im(i), correct);
correct            41 test/correctness/compute_outermost.cpp             int correct = 3*x + 4*y;
correct            42 test/correctness/compute_outermost.cpp             if (result(x, y) != correct) {
correct            44 test/correctness/compute_outermost.cpp                        x, y, result(x, y), correct);
correct           105 test/correctness/convolution.cpp             uint16_t correct = (1*in(x-1, y-1) + 2*in(x, y-1) + 1*in(x+1, y-1) +
correct           108 test/correctness/convolution.cpp             if (out1(x, y) != correct) {
correct           109 test/correctness/convolution.cpp                 printf("out1(%d, %d) = %d instead of %d\n", x, y, out1(x, y), correct);
correct           112 test/correctness/convolution.cpp             if (out2(x, y) != correct) {
correct           113 test/correctness/convolution.cpp                 printf("out2(%d, %d) = %d instead of %d\n", x, y, out2(x, y), correct);
correct            56 test/correctness/convolution_multiple_kernels.cpp             uint16_t correct = (in(x-1, y-1) + in(x, y-1) + in(x+1, y-1) +
correct            60 test/correctness/convolution_multiple_kernels.cpp             if (out(x, y) != correct) {
correct            61 test/correctness/convolution_multiple_kernels.cpp                 printf("out(%d, %d) = %d instead of %d\n", x, y, out(x, y), correct);
correct            82 test/correctness/debug_to_file.cpp             float correct = (float)(f_data[y*11+x] + f_data[y*11+x+1]);
correct            83 test/correctness/debug_to_file.cpp             if (val != correct) {
correct            84 test/correctness/debug_to_file.cpp                 printf("g_data[%d, %d] = %f instead of %f\n", x, y, val, correct);
correct           103 test/correctness/debug_to_file.cpp             float correct = f_data[y*11+x] + g_data[y*10+x];
correct           104 test/correctness/debug_to_file.cpp             if (val != correct) {
correct           105 test/correctness/debug_to_file.cpp                 printf("h_data[%d, %d] = %f instead of %f\n", x, y, val, correct);
correct            81 test/correctness/debug_to_file_multiple_outputs.cpp             float correct = (float)(f_data[y*(size_x+1)+x] + f_data[y*(size_x+1)+x+1]);
correct            82 test/correctness/debug_to_file_multiple_outputs.cpp             if (val != correct) {
correct            83 test/correctness/debug_to_file_multiple_outputs.cpp                 printf("g_data[%d, %d] = %f instead of %f\n", x, y, val, correct);
correct           102 test/correctness/debug_to_file_multiple_outputs.cpp             float correct = f_data[y*(size_x+1)+x] + g_data[y*size_x+x];
correct           103 test/correctness/debug_to_file_multiple_outputs.cpp             if (val != correct) {
correct           104 test/correctness/debug_to_file_multiple_outputs.cpp                 printf("h_data[%d, %d] = %f instead of %f\n", x, y, val, correct);
correct            84 test/correctness/debug_to_file_reorder.cpp             float correct = (float)(f_data[y*(size_x+1)+x] + f_data[y*(size_x+1)+x+1]);
correct            85 test/correctness/debug_to_file_reorder.cpp             if (val != correct) {
correct            86 test/correctness/debug_to_file_reorder.cpp                 printf("g_data[%d, %d] = %f instead of %f\n", x, y, val, correct);
correct           105 test/correctness/debug_to_file_reorder.cpp             float correct = f_data[y*(size_x+1)+x] + g_data[y*size_x+x];
correct           106 test/correctness/debug_to_file_reorder.cpp             if (val != correct) {
correct           107 test/correctness/debug_to_file_reorder.cpp                 printf("h_data[%d, %d] = %f instead of %f\n", x, y, val, correct);
correct            44 test/correctness/dilate3x3.cpp             uint16_t correct = std::max({ std::max({ in(x-1, y-1), in(x, y-1), in(x+1, y-1) }),
correct            48 test/correctness/dilate3x3.cpp             if (out(x, y) != correct) {
correct            49 test/correctness/dilate3x3.cpp                 std::cout << "out(" << x << ", " << y << ") = " << out(x, y) << " instead of " << correct << "\n";
correct            34 test/correctness/erf.cpp         float correct = erff(x);
correct            36 test/correctness/erf.cpp         int err = bits_diff(correct, approx);
correct           102 test/correctness/exception.cpp         float correct = i * 14.0f;
correct           103 test/correctness/exception.cpp         if (result(i) != correct) {
correct           106 test/correctness/exception.cpp                       << " instead of " << correct << "\n";
correct            40 test/correctness/extern_consumer.cpp     const char *correct =
correct            60 test/correctness/extern_consumer.cpp     if (strncmp(result, correct, 1023)) {
correct            67 test/correctness/extern_output_expansion.cpp             int32_t correct = i*i*i*2;
correct            68 test/correctness/extern_output_expansion.cpp             if (result(i) != correct) {
correct            69 test/correctness/extern_output_expansion.cpp                 printf("result(%d) = %d instead of %d\n", i, result(i), correct);
correct            97 test/correctness/extern_stage.cpp         uint8_t correct = 4*i*i;
correct            98 test/correctness/extern_stage.cpp         if (result(i) != correct) {
correct            99 test/correctness/extern_stage.cpp             printf("result(%d) = %d instead of %d\n", i, result(i), correct);
correct            19 test/correctness/for_each_element.cpp             int correct = 10*x + 5*y + c;
correct            20 test/correctness/for_each_element.cpp             if (im(x, y, c) != correct) {
correct            22 test/correctness/for_each_element.cpp                        x, y, c, im(x, y, c), correct);
correct            30 test/correctness/for_each_element.cpp                 int correct = (10*x + 5*y + c)*3;
correct            31 test/correctness/for_each_element.cpp                 if (im(x, y, c) != correct) {
correct            33 test/correctness/for_each_element.cpp                            x, y, c, im(x, y, c), correct);
correct            43 test/correctness/for_each_element.cpp                 int correct = (10*x + 5*y + c)*6;
correct            44 test/correctness/for_each_element.cpp                 if (im(x, y, c) != correct) {
correct            46 test/correctness/for_each_element.cpp                            x, y, c, im(x, y, c), correct);
correct            57 test/correctness/for_each_element.cpp                 int correct = (10*x + 5*y + c)*12;
correct            58 test/correctness/for_each_element.cpp                 if (im(x, y, c) != correct) {
correct            60 test/correctness/for_each_element.cpp                            x, y, c, im(x, y, c), correct);
correct            12 test/correctness/func_lifetime.cpp             int correct = i*j + add;
correct            13 test/correctness/func_lifetime.cpp             if (im(i, j) != correct) {
correct            14 test/correctness/func_lifetime.cpp                 printf("im[%d, %d] = %d instead of %d\n", i, j, im(i, j), correct);
correct            12 test/correctness/func_lifetime_2.cpp             int correct = i*j + add;
correct            13 test/correctness/func_lifetime_2.cpp             if (im(i, j) != correct) {
correct            14 test/correctness/func_lifetime_2.cpp                 printf("im[%d, %d] = %d instead of %d\n", i, j, im(i, j), correct);
correct            51 test/correctness/gpu_data_flows.cpp             int correct = (input(x) + 1) * 2 + 3;
correct            52 test/correctness/gpu_data_flows.cpp             if (output1(x) != correct) {
correct            53 test/correctness/gpu_data_flows.cpp                 printf("output1(%d) = %d instead of %d\n", x, output1(x), correct);
correct            85 test/correctness/gpu_data_flows.cpp             int correct = (input(x) + 1) * 2;
correct            86 test/correctness/gpu_data_flows.cpp             if (output2(x) != correct) {
correct            87 test/correctness/gpu_data_flows.cpp                 printf("output2(%d) = %d instead of %d\n", x, output2(x), correct);
correct            25 test/correctness/gpu_dynamic_shared.cpp         int correct = 3*x;
correct            26 test/correctness/gpu_dynamic_shared.cpp         if (out(x) != correct) {
correct            28 test/correctness/gpu_dynamic_shared.cpp                    x, out(x), correct);
correct            40 test/correctness/gpu_mixed_dimensionality.cpp                 int correct = x + y + z + 4;
correct            41 test/correctness/gpu_mixed_dimensionality.cpp                 if (o(x, y, z) != correct) {
correct            43 test/correctness/gpu_mixed_dimensionality.cpp                            x, y, z, o(x, y, z), correct);
correct             9 test/correctness/gpu_mixed_shared_mem_types.cpp         T correct = n_types * (static_cast<uint16_t>(x) / 16) + offset;
correct            10 test/correctness/gpu_mixed_shared_mem_types.cpp         if (output(x) != correct) {
correct            12 test/correctness/gpu_mixed_shared_mem_types.cpp                    (unsigned int)x, (unsigned int)output(x), (unsigned int)correct);
correct            59 test/correctness/gpu_multi_device.cpp                     float correct = 42.0f + stages * 69;
correct            60 test/correctness/gpu_multi_device.cpp                     if (result(i, j, k) != correct) {
correct            61 test/correctness/gpu_multi_device.cpp                         printf("result(%d, %d, %d) = %f instead of %f. (%s).\n", i, j, k, result(i, j, k), correct, test_case);
correct            65 test/correctness/gpu_non_contiguous_copy.cpp                     int correct;
correct            71 test/correctness/gpu_non_contiguous_copy.cpp                         correct = 3*x_ + 2*y_ + z_ + 4*w_;
correct            73 test/correctness/gpu_non_contiguous_copy.cpp                         correct = 4*x + 3*y + 2*z + w;
correct            75 test/correctness/gpu_non_contiguous_copy.cpp                     if (full(x, y, z, w) != correct) {
correct            76 test/correctness/gpu_non_contiguous_copy.cpp                         printf("Error! Incorrect value %i != %i at %i, %i, %i, %i\n", full(x, y, z, w), correct, x, y, z, w);
correct            30 test/correctness/gpu_reuse_shared_memory.cpp     uint8_t correct = 32;
correct            34 test/correctness/gpu_reuse_shared_memory.cpp                 if (out(x, y, z) != correct) {
correct            36 test/correctness/gpu_reuse_shared_memory.cpp                            x, y, z, out(x, y, z), correct);
correct            71 test/correctness/gpu_reuse_shared_memory.cpp     int correct = 1;
correct            74 test/correctness/gpu_reuse_shared_memory.cpp             if (out(x, y) != correct) {
correct            76 test/correctness/gpu_reuse_shared_memory.cpp                        x, y, out(x, y), correct);
correct           115 test/correctness/gpu_reuse_shared_memory.cpp     int correct = 1;
correct           118 test/correctness/gpu_reuse_shared_memory.cpp             if (out(x, y) != correct) {
correct           120 test/correctness/gpu_reuse_shared_memory.cpp                        x, y, out(x, y), correct);
correct           153 test/correctness/gpu_reuse_shared_memory.cpp         int correct = 27*x;
correct           154 test/correctness/gpu_reuse_shared_memory.cpp         if (out(x) != correct) {
correct           156 test/correctness/gpu_reuse_shared_memory.cpp                    x, out(x), correct);
correct            56 test/correctness/gpu_specialize.cpp                 int correct = 6*x + 5*y;
correct            57 test/correctness/gpu_specialize.cpp                 if (out1(x, y) != correct) {
correct            59 test/correctness/gpu_specialize.cpp                            x, y, out1(x, y), correct);
correct            62 test/correctness/gpu_specialize.cpp                 if (out2(x, y) != correct) {
correct            64 test/correctness/gpu_specialize.cpp                            x, y, out2(x, y), correct);
correct            93 test/correctness/gpu_specialize.cpp                 int correct = 2*x + y;
correct            94 test/correctness/gpu_specialize.cpp                 if (out(x, y) != correct) {
correct            96 test/correctness/gpu_specialize.cpp                            x, y, out(x, y), correct);
correct            54 test/correctness/gpu_sum_scan.cpp     int correct = 0;
correct            56 test/correctness/gpu_sum_scan.cpp         correct += input(i);
correct            57 test/correctness/gpu_sum_scan.cpp         if (output(i) != correct) {
correct            59 test/correctness/gpu_sum_scan.cpp                    i, output(i), correct);
correct            25 test/correctness/gpu_thread_barrier.cpp     int correct;
correct            27 test/correctness/gpu_thread_barrier.cpp     CheckBarrierCount(int correct) : correct(correct) {}
correct            34 test/correctness/gpu_thread_barrier.cpp         if (c.count != correct) {
correct            35 test/correctness/gpu_thread_barrier.cpp             printf("There were %d barriers. There were supposed to be %d\n", c.count, correct);
correct            87 test/correctness/gpu_thread_barrier.cpp                 int correct = 7*100 + 9;
correct            88 test/correctness/gpu_thread_barrier.cpp                 if (out(x, y) != correct) {
correct            90 test/correctness/gpu_thread_barrier.cpp                            x, y, out(x, y), correct);
correct            46 test/correctness/gpu_transpose.cpp             uint8_t correct = y * 17 + x;
correct            47 test/correctness/gpu_transpose.cpp             if (output(x, y) != correct) {
correct            49 test/correctness/gpu_transpose.cpp                        x, y, output(x, y), correct);
correct            30 test/correctness/gpu_vectorized_shared_memory.cpp             int correct = 4*x + 90;
correct            31 test/correctness/gpu_vectorized_shared_memory.cpp             if (out(x) != correct) {
correct            33 test/correctness/gpu_vectorized_shared_memory.cpp                        x, out(x), correct);
correct            36 test/correctness/handle.cpp         int correct = my_strlen(c_message);
correct            37 test/correctness/handle.cpp         if (result != correct) {
correct            39 test/correctness/handle.cpp                    c_message, result, correct);
correct            28 test/correctness/hello_gpu.cpp             float correct = i*j + 2.4f;
correct            29 test/correctness/hello_gpu.cpp             if (fabs(imf(i, j) - correct) > 0.001f) {
correct            30 test/correctness/hello_gpu.cpp                 printf("imf[%d, %d] = %f instead of %f\n", i, j, imf(i, j), correct);
correct            57 test/correctness/histogram_equalize.cpp         int correct = (in.width()*in.height())/16;
correct            58 test/correctness/histogram_equalize.cpp         if (out_hist[i] < correct/2 || out_hist[i] > 2*correct) {
correct            59 test/correctness/histogram_equalize.cpp             printf("Expected histogram entries of ~ %d\n", correct);
correct            33 test/correctness/implicit_args.cpp                     int correct = i*j*k + x+i + i+j;
correct            34 test/correctness/implicit_args.cpp                     if (result1(x, i, j, k) != correct) {
correct            36 test/correctness/implicit_args.cpp                                x, i, j, k, result1(x, i, j, k), correct);
correct            59 test/correctness/implicit_args.cpp             int correct = 2*i*j + 2+2 + 2+i + 1+i;
correct            60 test/correctness/implicit_args.cpp             if (result2(i, j) != correct) {
correct            62 test/correctness/implicit_args.cpp                        i, j, result2(i, j), correct);
correct            81 test/correctness/implicit_args.cpp                    int correct = (i<<24)|(j<<16)|(l<<8)|k;
correct            82 test/correctness/implicit_args.cpp                    if (transposed(i, j, k, l) != correct) {
correct            84 test/correctness/implicit_args.cpp                                 i, j, k, l, transposed(i, j, k, l), correct);
correct           105 test/correctness/implicit_args.cpp                    int correct = correct1 + correct2;
correct           106 test/correctness/implicit_args.cpp                    if (hairy_transposed(i, j, k, l) != correct) {
correct           108 test/correctness/implicit_args.cpp                                 i, j, k, l, hairy_transposed(i, j, k, l), correct);
correct           129 test/correctness/implicit_args.cpp                    int correct = correct1 + correct2;
correct           130 test/correctness/implicit_args.cpp                    if (hairy_transposed2(i, j, k, l) != correct) {
correct           132 test/correctness/implicit_args.cpp                                 i, j, k, l, hairy_transposed2(i, j, k, l), correct);
correct            16 test/correctness/implicit_args_tests.cpp                     int correct = funcs[idx](x, y, z);
correct            17 test/correctness/implicit_args_tests.cpp                     if (im(x, y, z) != correct) {
correct            19 test/correctness/implicit_args_tests.cpp                                x, y, z, im(x, y, z), correct);
correct            63 test/correctness/in_place.cpp         double correct = sin((double)x);
correct            65 test/correctness/in_place.cpp             correct = 1.0;
correct            67 test/correctness/in_place.cpp         if (fabs(data(x) - correct) > 0.001) {
correct            68 test/correctness/in_place.cpp             printf("data(%d) = %f instead of %f\n", x, data(x), correct);
correct            35 test/correctness/inline_reduction.cpp             float correct = local_variance/81.0f - local_mean*local_mean;
correct            37 test/correctness/inline_reduction.cpp             float delta = correct - r;
correct            39 test/correctness/inline_reduction.cpp                 printf("result(%d, %d) was %f instead of %f\n", x, y, r, correct);
correct            36 test/correctness/interleave.cpp void check_interleave_count(Func f, int correct) {
correct            38 test/correctness/interleave.cpp     if (c < correct) {
correct            40 test/correctness/interleave.cpp                f.name().c_str(), correct, c);
correct           114 test/correctness/interleave.cpp                 float correct = ((x % 2) == 0) ? (1.0f/(sinf(x/2 + i))) : (cosf(x/2 + i)*17.0f);
correct           115 test/correctness/interleave.cpp                 float delta = result(x) - correct;
correct           117 test/correctness/interleave.cpp                     printf("result(%d) = %f instead of %f\n", x, result(x), correct);
correct           160 test/correctness/interleave.cpp                 float correct = 3*x + y;
correct           161 test/correctness/interleave.cpp                 float delta = buff3(x, y) - correct;
correct           163 test/correctness/interleave.cpp                     printf("result(%d) = %f instead of %f\n", x, buff3(x,y), correct);
correct           208 test/correctness/interleave.cpp                 float correct = sin((y+1)*x);
correct           209 test/correctness/interleave.cpp                 float delta = buff4(x, y) - correct;
correct           211 test/correctness/interleave.cpp                     printf("result(%d) = %f instead of %f\n", x, buff4(x,y), correct);
correct           249 test/correctness/interleave.cpp                 float correct = sin((y+1)*x);
correct           250 test/correctness/interleave.cpp                 float delta = buff5(x, y) - correct;
correct           252 test/correctness/interleave.cpp                     printf("result(%d) = %f instead of %f\n", x, buff5(x,y), correct);
correct           397 test/correctness/interleave.cpp                 int correct = 5*y + x;
correct           398 test/correctness/interleave.cpp                 if (result6(x,y) != correct) {
correct           399 test/correctness/interleave.cpp                     printf("result(%d) = %d instead of %d\n", x, result6(x,y), correct);
correct           403 test/correctness/interleave.cpp                 if (result7(x,y) != correct) {
correct           404 test/correctness/interleave.cpp                     printf("result(%d) = %d instead of %d\n", x, result7(x,y), correct);
correct            38 test/correctness/interleave_rgb.cpp                 T correct = x * 3 + y * 5 + c;
correct            39 test/correctness/interleave_rgb.cpp                 if (buff(x, y, c) != correct) {
correct            40 test/correctness/interleave_rgb.cpp                     printf("out(%d, %d, %d) = %d instead of %d\n", x, y, c, buff(x, y, c), correct);
correct            27 test/correctness/interleave_x.cpp             uint16_t correct = x%2 == 0 ? 3 : 7;
correct            28 test/correctness/interleave_x.cpp             if (out(x, y) != correct) {
correct            29 test/correctness/interleave_x.cpp                 printf("out(%d, %d) = %d instead of %d\n", x, y, out(x, y), correct);
correct            21 test/correctness/lambda.cpp             int correct = x+y;
correct            22 test/correctness/lambda.cpp             if (im(x, y) != correct) {
correct            23 test/correctness/lambda.cpp                 printf("im(%d, %d) = %d instead of %d\n", x, y, im(x, y), correct);
correct            39 test/correctness/lambda.cpp                 int correct = x+y*y+z*z*z;
correct            40 test/correctness/lambda.cpp                 if (im2(x, y, z) != correct) {
correct            41 test/correctness/lambda.cpp                     printf("im2(%d, %d, %d) = %d instead of %d\n", x, y, z, im2(x, y, z), correct);
correct            27 test/correctness/legal_race_condition.cpp             int correct = (i < 50) ? i : 0;
correct            28 test/correctness/legal_race_condition.cpp             if (out(i) != correct) {
correct            30 test/correctness/legal_race_condition.cpp                        i, out(i), correct);
correct            35 test/correctness/likely.cpp     int correct;
correct            42 test/correctness/likely.cpp         if (c.sin_count != correct) {
correct            43 test/correctness/likely.cpp             printf("There were %d sin calls instead of %d\n", c.sin_count, correct);
correct            49 test/correctness/likely.cpp     CheckSinCount(int c) : correct(c) {}
correct            55 test/correctness/likely.cpp     int correct;
correct            62 test/correctness/likely.cpp         if (c.store_count != correct) {
correct            63 test/correctness/likely.cpp             printf("There were %d stores to %s instead of %d\n", c.store_count, func.c_str(), correct);
correct            72 test/correctness/likely.cpp void count_partitions(Func g, int correct) {
correct            73 test/correctness/likely.cpp     g.add_custom_lowering_pass(new CheckStoreCount(g.name(), correct));
correct            77 test/correctness/likely.cpp void count_sin_calls(Func g, int correct) {
correct            78 test/correctness/likely.cpp     g.add_custom_lowering_pass(new CheckSinCount(correct));
correct            46 test/correctness/logical.cpp                 uint8_t correct = cond ? 255 : 0;
correct            47 test/correctness/logical.cpp                 if (correct != output(x, y)) {
correct            48 test/correctness/logical.cpp                     printf("output(%d, %d) = %d instead of %d\n", x, y, output(x, y), correct);
correct            80 test/correctness/logical.cpp                 uint8_t correct = cond ? 255 : 0;
correct            81 test/correctness/logical.cpp                 if (correct != output(x, y)) {
correct            82 test/correctness/logical.cpp                     printf("output(%d, %d) = %d instead of %d\n", x, y, output(x, y), correct);
correct           109 test/correctness/logical.cpp                 uint8_t correct = cond ? 0 : input(x,y);
correct           110 test/correctness/logical.cpp                 if (correct != output(x, y)) {
correct           111 test/correctness/logical.cpp                     printf("output(%d, %d) = %d instead of %d\n", x, y, output(x, y), correct);
correct           138 test/correctness/logical.cpp                 uint8_t correct = cond ? 255 : 0;
correct           139 test/correctness/logical.cpp                 if (correct != output(x, y)) {
correct           140 test/correctness/logical.cpp                     printf("output(%d, %d) = %d instead of %d\n", x, y, output(x, y), correct);
correct            45 test/correctness/loop_invariant_extern_calls.cpp             int correct = y + 32*x + y;
correct            46 test/correctness/loop_invariant_extern_calls.cpp             if (im(x, y) != correct) {
correct            47 test/correctness/loop_invariant_extern_calls.cpp                 printf("im(%d, %d) = %d instead of %d\n", x, y, im(x, y), correct);
correct            50 test/correctness/lots_of_dimensions.cpp             uint64_t correct = fn(i0, i1, i2, i3, i4, i5, i6, i7);
correct            52 test/correctness/lots_of_dimensions.cpp             if (actual != correct) {
correct            54 test/correctness/lots_of_dimensions.cpp                        i0, i1, i2, i3, i4, i5, i6, i7, (long long unsigned)actual, (long long unsigned)correct);
correct            86 test/correctness/lots_of_dimensions.cpp                                         uint64_t correct = in(i0, i1, i2, i3, i4, i5, i6, i7);
correct            87 test/correctness/lots_of_dimensions.cpp                                         correct *= correct;
correct            88 test/correctness/lots_of_dimensions.cpp                                         correct -= 3;
correct            90 test/correctness/lots_of_dimensions.cpp                                         if (actual != correct) {
correct            93 test/correctness/lots_of_dimensions.cpp                                                    (long long unsigned)actual, (long long unsigned)correct);
correct            70 test/correctness/many_small_extern_stages.cpp             uint8_t correct = 0;
correct            72 test/correctness/many_small_extern_stages.cpp                 printf("result(%d, %d) = %d instead of %d\n", x, y, result(x, y), correct);
correct            65 test/correctness/median3x3.cpp             uint8_t correct = inp[4];
correct            66 test/correctness/median3x3.cpp             if (correct != out(x, y)) {
correct            67 test/correctness/median3x3.cpp                 std::cout << "out(" << x << ", " << y << ") = " << out(x, y) << " instead of " << correct << "\n";
correct           318 test/correctness/mul_div_mod.cpp             RT correct = RT(ai)*RT(bi);
correct           319 test/correctness/mul_div_mod.cpp             if (correct != ri && (ecount++) < 10) {
correct           320 test/correctness/mul_div_mod.cpp                 std::cerr << ai << "*" << bi << " -> " << ri << " != " << correct << "\n";
correct            67 test/correctness/multi_pass_reduction.cpp         int correct[110];
correct            69 test/correctness/multi_pass_reduction.cpp             correct[i] = i;
correct            72 test/correctness/multi_pass_reduction.cpp             correct[i] += correct[i-1];
correct            74 test/correctness/multi_pass_reduction.cpp         correct[17] = 8;
correct            75 test/correctness/multi_pass_reduction.cpp         correct[109] = 4;
correct            77 test/correctness/multi_pass_reduction.cpp             correct[i] = i*i;
correct            81 test/correctness/multi_pass_reduction.cpp             if (correct[i] != result(i)) {
correct            83 test/correctness/multi_pass_reduction.cpp                        i, result(i), correct[i]);
correct            58 test/correctness/newtons_method.cpp     T correct = (T)M_PI;
correct            59 test/correctness/newtons_method.cpp     if (newton_result != correct ||
correct            60 test/correctness/newtons_method.cpp         secant_result != correct) {
correct            62 test/correctness/newtons_method.cpp                newton_result, secant_result, correct);
correct            28 test/correctness/obscure_image_references.cpp         int correct = i < im2(3) ? 37 : (i+20);
correct            29 test/correctness/obscure_image_references.cpp         if (result(i) != correct) {
correct            30 test/correctness/obscure_image_references.cpp             printf("result(%d) = %d instead of %d\n", i, result(i), correct);
correct            29 test/correctness/parallel_reductions.cpp         int correct = (256*255)/2;
correct            30 test/correctness/parallel_reductions.cpp         if (im(0) != correct) {
correct            31 test/correctness/parallel_reductions.cpp             printf("im(0) = %d instead of %d\n", im(0), correct);
correct            41 test/correctness/parallel_reductions.cpp         Buffer<int> input(256), correct(256);
correct            44 test/correctness/parallel_reductions.cpp             correct(i) = input(i);
correct            45 test/correctness/parallel_reductions.cpp             if (i > 0) correct(i) += correct(i-1);
correct            78 test/correctness/parallel_reductions.cpp             if (result(i) != correct(i)) {
correct            79 test/correctness/parallel_reductions.cpp                 printf("result(%d) = %d instead of %d\n", i, result(i), correct(i));
correct            40 test/correctness/partition_loops.cpp                 float correct = (input(2*x, y, 2) < x + y) ? x + y : y + c;
correct            41 test/correctness/partition_loops.cpp                 if (im(x, y, c) != correct) {
correct            43 test/correctness/partition_loops.cpp                            x, y, c, im(x, y, c), correct);
correct            37 test/correctness/pipeline_set_jit_externs_func.cpp             float correct = (float)(i*j);
correct            38 test/correctness/pipeline_set_jit_externs_func.cpp             float delta = imf(i, j) - correct;
correct            40 test/correctness/pipeline_set_jit_externs_func.cpp                 printf("imf[%d, %d] = %f instead of %f\n", i, j, imf(i, j), correct);
correct           158 test/correctness/print.cpp         char correct[1024];
correct           160 test/correctness/print.cpp             snprintf(correct, sizeof(correct), "%f\n", imf(i));
correct           166 test/correctness/print.cpp             if (!strcmp(correct, "-nan\n")) strcpy(correct, "nan\n");
correct           167 test/correctness/print.cpp             if (messages[i] != correct) {
correct           168 test/correctness/print.cpp                 printf("float %d: %s vs %s for %10.20e\n", i, messages[i].c_str(), correct, imf(i));
correct           182 test/correctness/print.cpp             snprintf(correct, sizeof(correct), "%e\n", img(i));
correct           188 test/correctness/print.cpp             if (!strcmp(correct, "-nan\n")) strcpy(correct, "nan\n");
correct           189 test/correctness/print.cpp             if (messages[i] != correct) {
correct           190 test/correctness/print.cpp                 printf("double %d: %s vs %s for %10.20e\n", i, messages[i].c_str(), correct, img(i));
correct            95 test/correctness/process_some_tiles.cpp             float correct = active ? my_powf(image_buf(x, y), 0.8f) : image_buf(x, y);
correct            96 test/correctness/process_some_tiles.cpp             if (fabs(correct - result(x, y)) > 0.001f) {
correct            98 test/correctness/process_some_tiles.cpp                        x, y, result(x, y), correct);
correct           128 test/correctness/random.cpp         int correct = 512 * 1024 * 32;
correct           129 test/correctness/random.cpp         if (fabs(double(set_bits) / correct - 1) > tol) {
correct           130 test/correctness/random.cpp             printf("Set bits was %d instead of %d\n", set_bits, correct);
correct           137 test/correctness/random.cpp         if (fabs(double(set_bits) / correct - 1) > tol) {
correct           138 test/correctness/random.cpp             printf("Set bits was %d instead of %d\n", set_bits, correct);
correct            93 test/correctness/reduction_non_rectangular.cpp             int correct = x + y;
correct            95 test/correctness/reduction_non_rectangular.cpp                 correct += (x < y) ? 1 : 0;
correct            97 test/correctness/reduction_non_rectangular.cpp             if (im(x, y) != correct) {
correct            99 test/correctness/reduction_non_rectangular.cpp                        x, y, im(x, y), correct);
correct           126 test/correctness/reduction_non_rectangular.cpp             int correct = x + y;
correct           128 test/correctness/reduction_non_rectangular.cpp                 correct += (x < y) ? 1 : 0;
correct           130 test/correctness/reduction_non_rectangular.cpp             if (im(x, y) != correct) {
correct           132 test/correctness/reduction_non_rectangular.cpp                        x, y, im(x, y), correct);
correct           155 test/correctness/reduction_non_rectangular.cpp                 int correct = x + y + z;
correct           157 test/correctness/reduction_non_rectangular.cpp                     correct += (x < y + z) ? 1 : 0;
correct           159 test/correctness/reduction_non_rectangular.cpp                 if (im(x, y, z) != correct) {
correct           161 test/correctness/reduction_non_rectangular.cpp                            x, y, z, im(x, y, z), correct);
correct           198 test/correctness/reduction_non_rectangular.cpp             int correct = x + y;
correct           200 test/correctness/reduction_non_rectangular.cpp                 correct += (x < y+10) ? 1 : 0;
correct           202 test/correctness/reduction_non_rectangular.cpp             if (im(x, y) != correct) {
correct           204 test/correctness/reduction_non_rectangular.cpp                        x, y, im(x, y), correct);
correct           237 test/correctness/reduction_non_rectangular.cpp             int correct = x + y;
correct           239 test/correctness/reduction_non_rectangular.cpp                 correct += (x < y + 2*x) ? 1 : 0;
correct           241 test/correctness/reduction_non_rectangular.cpp             if (im(x, y) != correct) {
correct           243 test/correctness/reduction_non_rectangular.cpp                        x, y, im(x, y), correct);
correct           278 test/correctness/reduction_non_rectangular.cpp             int correct = x + y;
correct           280 test/correctness/reduction_non_rectangular.cpp                 correct = ((2*x + 30 < y) && (y >= 100 - x)) ? 3*correct : correct;
correct           282 test/correctness/reduction_non_rectangular.cpp             if (im(x, y) != correct) {
correct           284 test/correctness/reduction_non_rectangular.cpp                        x, y, im(x, y), correct);
correct           325 test/correctness/reduction_non_rectangular.cpp             int correct = x + y;
correct           327 test/correctness/reduction_non_rectangular.cpp                 correct += (x*x + y*y <= 100) ? x : 0;
correct           329 test/correctness/reduction_non_rectangular.cpp             if (im(x, y) != correct) {
correct           331 test/correctness/reduction_non_rectangular.cpp                        x, y, im(x, y), correct);
correct           370 test/correctness/reduction_non_rectangular.cpp                 int correct = x + y;
correct           372 test/correctness/reduction_non_rectangular.cpp                     correct = 3*correct;
correct           374 test/correctness/reduction_non_rectangular.cpp                 if (im(x, y) != correct) {
correct           376 test/correctness/reduction_non_rectangular.cpp                            x, y, im(x, y), correct);
correct           397 test/correctness/reduction_non_rectangular.cpp                 int correct = x + y;
correct           398 test/correctness/reduction_non_rectangular.cpp                 if (im(x, y) != correct) {
correct           400 test/correctness/reduction_non_rectangular.cpp                            x, y, im(x, y), correct);
correct           442 test/correctness/reduction_non_rectangular.cpp             int correct = x + y;
correct           445 test/correctness/reduction_non_rectangular.cpp                     correct = x;
correct           448 test/correctness/reduction_non_rectangular.cpp             if (im(x, y) != correct) {
correct           450 test/correctness/reduction_non_rectangular.cpp                        x, y, im(x, y), correct);
correct           496 test/correctness/reduction_non_rectangular.cpp             int correct = x + y;
correct           498 test/correctness/reduction_non_rectangular.cpp                 correct += (x < y) ? x : 0;
correct           500 test/correctness/reduction_non_rectangular.cpp             if (im(x, y) != correct) {
correct           502 test/correctness/reduction_non_rectangular.cpp                        x, y, im(x, y), correct);
correct           537 test/correctness/reduction_non_rectangular.cpp             int correct = x + y;
correct           539 test/correctness/reduction_non_rectangular.cpp                 correct += ((correct >= 40) && (correct != 50)) ? 1 : 0;
correct           541 test/correctness/reduction_non_rectangular.cpp             if (im1(x, y) != correct) {
correct           543 test/correctness/reduction_non_rectangular.cpp                        x, y, im1(x, y), correct);
correct           552 test/correctness/reduction_non_rectangular.cpp             int correct = 10;
correct           554 test/correctness/reduction_non_rectangular.cpp                 correct += (im1(x, y) < 30) ? im1(x, y) : 0;
correct           556 test/correctness/reduction_non_rectangular.cpp             if (im2(x, y) != correct) {
correct           558 test/correctness/reduction_non_rectangular.cpp                        x, y, im2(x, y), correct);
correct           588 test/correctness/reduction_non_rectangular.cpp             int correct = x + y;
correct           590 test/correctness/reduction_non_rectangular.cpp                 correct += im0(x, y) ? 10 : 0;
correct           592 test/correctness/reduction_non_rectangular.cpp             if (im1(x, y) != correct) {
correct           594 test/correctness/reduction_non_rectangular.cpp                        x, y, im1(x, y), correct);
correct           661 test/correctness/reduction_non_rectangular.cpp             int correct = x + y;
correct           663 test/correctness/reduction_non_rectangular.cpp                 correct += (x < y) ? 3 : 0;
correct           665 test/correctness/reduction_non_rectangular.cpp             if (im(x, y) != correct) {
correct           667 test/correctness/reduction_non_rectangular.cpp                        x, y, im(x, y), correct);
correct           693 test/correctness/reduction_non_rectangular.cpp             int correct = x + y;
correct           695 test/correctness/reduction_non_rectangular.cpp                 correct += (x < y) ? 3 : 0;
correct           697 test/correctness/reduction_non_rectangular.cpp             if (im(x, y) != correct) {
correct           699 test/correctness/reduction_non_rectangular.cpp                        x, y, im(x, y), correct);
correct           742 test/correctness/reduction_non_rectangular.cpp                 int correct = x + y;
correct           744 test/correctness/reduction_non_rectangular.cpp                     correct = 3*correct;
correct           746 test/correctness/reduction_non_rectangular.cpp                 if (im(x, y) != correct) {
correct           748 test/correctness/reduction_non_rectangular.cpp                            x, y, im(x, y), correct);
correct           764 test/correctness/reduction_non_rectangular.cpp                 int correct = x + y;
correct           766 test/correctness/reduction_non_rectangular.cpp                     correct += 10 + correct;
correct           768 test/correctness/reduction_non_rectangular.cpp                 if (im(x, y) != correct) {
correct           770 test/correctness/reduction_non_rectangular.cpp                            x, y, im(x, y), correct);
correct           798 test/correctness/reduction_non_rectangular.cpp             int correct = 0;
correct           801 test/correctness/reduction_non_rectangular.cpp                 correct += 10;
correct           803 test/correctness/reduction_non_rectangular.cpp             if (im(x, y) != correct) {
correct           805 test/correctness/reduction_non_rectangular.cpp                        x, y, im(x, y), correct);
correct            29 test/correctness/scatter.cpp         int correct = i < 5 ? (1617 + i*100) : 17;
correct            30 test/correctness/scatter.cpp         if (result(i, 0) != correct) {
correct            31 test/correctness/scatter.cpp             printf("Value at %d should have been %d but was instead %d\n", i, correct, result(i, 0));
correct            28 test/correctness/skip_stages.cpp     int correct[] = {a, b, c, d};
correct            30 test/correctness/skip_stages.cpp         if (correct[i] != call_count[i]) {
correct            31 test/correctness/skip_stages.cpp             printf("call_count[%d] was supposed to be %d but instead is %d\n", i, correct[i], call_count[i]);
correct            36 test/correctness/skip_stages_external_array_functions.cpp     int correct[] = {a, b, c, d};
correct            38 test/correctness/skip_stages_external_array_functions.cpp         if (correct[i] != bounds_query_count[i]) {
correct            39 test/correctness/skip_stages_external_array_functions.cpp             printf("bounds_query_count[%d] was supposed to be %d but instead is %d\n", i, correct[i], bounds_query_count[i]);
correct            46 test/correctness/skip_stages_external_array_functions.cpp     int correct[] = {a, b, c, d};
correct            48 test/correctness/skip_stages_external_array_functions.cpp         if (correct[i] != call_count[i]) {
correct            49 test/correctness/skip_stages_external_array_functions.cpp             printf("call_count[%d] was supposed to be %d but instead is %d\n", i, correct[i], call_count[i]);
correct            43 test/correctness/skip_stages_memoize.cpp         int correct = 1;
correct            45 test/correctness/skip_stages_memoize.cpp             correct = 2*x;
correct            47 test/correctness/skip_stages_memoize.cpp         if (out(x) != correct) {
correct            49 test/correctness/skip_stages_memoize.cpp                    x, out(x), correct);
correct            58 test/correctness/skip_stages_memoize.cpp         int correct;
correct            60 test/correctness/skip_stages_memoize.cpp             correct = 2*x;
correct            62 test/correctness/skip_stages_memoize.cpp             correct = x;
correct            64 test/correctness/skip_stages_memoize.cpp             correct = x + 1;
correct            66 test/correctness/skip_stages_memoize.cpp             correct = 1;
correct            68 test/correctness/skip_stages_memoize.cpp         if (out(x) != correct) {
correct            70 test/correctness/skip_stages_memoize.cpp                    x, out(x), correct);
correct            23 test/correctness/sliding_reduction.cpp             int correct = 99*3;
correct            24 test/correctness/sliding_reduction.cpp             if (im(x, y) != correct) {
correct            26 test/correctness/sliding_reduction.cpp                        x, y, im(x, y), correct);
correct            54 test/correctness/sliding_reduction.cpp         int correct = 24;
correct            55 test/correctness/sliding_reduction.cpp         if (counter != correct) {
correct            56 test/correctness/sliding_reduction.cpp             printf("Failed sliding a reduction: %d evaluations instead of %d\n", counter, correct);
correct            76 test/correctness/sliding_reduction.cpp         int correct = 60;
correct            77 test/correctness/sliding_reduction.cpp         if (counter != correct) {
correct            78 test/correctness/sliding_reduction.cpp             printf("Failed sliding a reduction: %d evaluations instead of %d\n", counter, correct);
correct           111 test/correctness/sliding_reduction.cpp         int correct = 42;
correct           112 test/correctness/sliding_reduction.cpp         if (counter != correct) {
correct           113 test/correctness/sliding_reduction.cpp             printf("Failed sliding a reduction: %d evaluations instead of %d\n", counter, correct);
correct           107 test/correctness/specialize.cpp             int correct = i*3;
correct           108 test/correctness/specialize.cpp             if (out(i) != correct) {
correct           110 test/correctness/specialize.cpp                        i, out(i), correct);
correct           116 test/correctness/specialize.cpp             int correct = i*17;
correct           117 test/correctness/specialize.cpp             if (out(i) != correct) {
correct           119 test/correctness/specialize.cpp                        i, out(i), correct);
correct           135 test/correctness/specialize.cpp             int correct = i*3;
correct           136 test/correctness/specialize.cpp             if (out(i) != correct) {
correct           138 test/correctness/specialize.cpp                        i, out(i), correct);
correct           144 test/correctness/specialize.cpp             int correct = i*17;
correct           145 test/correctness/specialize.cpp             if (out(i) != correct) {
correct           147 test/correctness/specialize.cpp                        i, out(i), correct);
correct            62 test/correctness/split_by_non_factor.cpp             int correct = (i - 3) + i*7;
correct            64 test/correctness/split_by_non_factor.cpp             if (actual != correct) {
correct            65 test/correctness/split_by_non_factor.cpp                 printf("result(%d) = %d instead of %d\n", i, actual, correct);
correct            33 test/correctness/split_store_compute.cpp             int correct = 17 * (v1 + v2 + v3 + v4 + v5);
correct            36 test/correctness/split_store_compute.cpp             if (val != correct) {
correct            38 test/correctness/split_store_compute.cpp                        i, j, val, correct);
correct           114 test/correctness/storage_folding.cpp                 int correct = (2*x) * (2*y) + (2*x+1) * (2*y+1);
correct           115 test/correctness/storage_folding.cpp                 if (im(x, y) != correct) {
correct           116 test/correctness/storage_folding.cpp                     printf("im(%d, %d) = %d instead of %d\n", x, y, im(x, y), correct);
correct           148 test/correctness/storage_folding.cpp                 int correct = x * (2*y) + (x+3) * (2*y+1);
correct           149 test/correctness/storage_folding.cpp                 if (im(x, y) != correct) {
correct           150 test/correctness/storage_folding.cpp                     printf("im(%d, %d) = %d instead of %d\n", x, y, im(x, y), correct);
correct           185 test/correctness/storage_folding.cpp                 int correct = (2*x) * y + (2*x+1) * (y+3);
correct           186 test/correctness/storage_folding.cpp                 if (im(x, y) != correct) {
correct           187 test/correctness/storage_folding.cpp                     printf("im(%d, %d) = %d instead of %d\n", x, y, im(x, y), correct);
correct           224 test/correctness/storage_folding.cpp                 int correct = x*y;
correct           225 test/correctness/storage_folding.cpp                 if (im(x, y) != correct) {
correct           226 test/correctness/storage_folding.cpp                     printf("im(%d, %d) = %d instead of %d\n", x, y, im(x, y), correct);
correct           262 test/correctness/storage_folding.cpp                 int correct = (2*x) * y + (2*x+1) * (y+2);
correct           263 test/correctness/storage_folding.cpp                 if (im(x, y) != correct) {
correct           264 test/correctness/storage_folding.cpp                     printf("im(%d, %d) = %d instead of %d\n", x, y, im(x, y), correct);
correct           296 test/correctness/storage_folding.cpp                 int correct = (x) * (y/2) + (x) * (y/2 + 1);
correct           297 test/correctness/storage_folding.cpp                 if (im(x, y) != correct) {
correct           298 test/correctness/storage_folding.cpp                     printf("im(%d, %d) = %d instead of %d\n", x, y, im(x, y), correct);
correct           170 test/correctness/tracing.cpp         event correct = {0};
correct           171 test/correctness/tracing.cpp         if (i < correct_trace_length) correct = correct_trace[i];
correct           173 test/correctness/tracing.cpp         if (!events_match(recorded, correct)) {
correct           176 test/correctness/tracing.cpp                 recorded.event_type == 0 && correct.event_type == 0) {
correct           183 test/correctness/tracing.cpp                 recorded.event_type == 0 && correct.event_type == 0) {
correct            66 test/correctness/trim_no_ops.cpp             int correct = x;
correct            67 test/correctness/trim_no_ops.cpp             correct += (x > 10 && x < 20) ? 1 : 0;
correct            68 test/correctness/trim_no_ops.cpp             correct += (x < 10) ? 0 : 1;
correct            69 test/correctness/trim_no_ops.cpp             correct *= (x > 20 && x < 30) ? 2 : 1;
correct            70 test/correctness/trim_no_ops.cpp             correct = (x >= 60 && x <= 100) ? (100 - correct) : correct;
correct            71 test/correctness/trim_no_ops.cpp             if (im(x) != correct) {
correct            73 test/correctness/trim_no_ops.cpp                        x, im(x), correct);
correct           101 test/correctness/trim_no_ops.cpp                 int correct = x + y;
correct           102 test/correctness/trim_no_ops.cpp                 correct += ((x == 10) && (x < y))? 1 : 0;
correct           103 test/correctness/trim_no_ops.cpp                 if (im(x, y) != correct) {
correct           105 test/correctness/trim_no_ops.cpp                            x, y, im(x, y), correct);
correct           218 test/correctness/trim_no_ops.cpp                 int correct = x + y;
correct           220 test/correctness/trim_no_ops.cpp                     correct += (x < y) ? 3 : 0;
correct           222 test/correctness/trim_no_ops.cpp                 if (im(x, y) != correct) {
correct           224 test/correctness/trim_no_ops.cpp                            x, y, im(x, y), correct);
correct            22 test/correctness/tuple_undef.cpp     int correct;
correct            24 test/correctness/tuple_undef.cpp     CheckStoreCount(int correct) : correct(correct) {}
correct            31 test/correctness/tuple_undef.cpp         if (c.count != correct) {
correct            32 test/correctness/tuple_undef.cpp             printf("There were %d stores. There were supposed to be %d\n", c.count, correct);
correct            43 test/correctness/unsafe_dedup_lets.cpp     int correct = 131;
correct            44 test/correctness/unsafe_dedup_lets.cpp     if (result != correct) {
correct            45 test/correctness/unsafe_dedup_lets.cpp         printf("Bad GCD: %d != %d\n", result, correct);
correct            19 test/correctness/vector_extern.cpp         float correct = sqrtf((float)i);
correct            20 test/correctness/vector_extern.cpp         if (fabs(im(i) - correct) > 0.001) {
correct            21 test/correctness/vector_extern.cpp             printf("im(%d) = %f instead of %f\n", i, im(i), correct);
correct           152 test/correctness/vector_math.cpp             A correct = input(x, y) + input(x+1, y);
correct           153 test/correctness/vector_math.cpp             if (im1(x, y) != correct) {
correct           154 test/correctness/vector_math.cpp                 printf("im1(%d, %d) = %f instead of %f\n", x, y, (double)(im1(x, y)), (double)(correct));
correct           169 test/correctness/vector_math.cpp             A correct = input(x, y) - input(x+1, y);
correct           170 test/correctness/vector_math.cpp             if (im2(x, y) != correct) {
correct           171 test/correctness/vector_math.cpp                 printf("im2(%d, %d) = %f instead of %f\n", x, y, (double)(im2(x, y)), (double)(correct));
correct           186 test/correctness/vector_math.cpp             A correct = input(x, y) * input(x+1, y);
correct           187 test/correctness/vector_math.cpp             if (im3(x, y) != correct) {
correct           188 test/correctness/vector_math.cpp                 printf("im3(%d, %d) = %f instead of %f\n", x, y, (double)(im3(x, y)), (double)(correct));
correct           203 test/correctness/vector_math.cpp             A correct = input(x, y) > input(x+1, y) ? input(x+2, y) : input(x+3, y);
correct           204 test/correctness/vector_math.cpp             if (im4(x, y) != correct) {
correct           205 test/correctness/vector_math.cpp                 printf("im4(%d, %d) = %f instead of %f\n", x, y, (double)(im4(x, y)), (double)(correct));
correct           231 test/correctness/vector_math.cpp             A correct = input(xCoord, yCoord);
correct           233 test/correctness/vector_math.cpp             if (im5(x, y) != correct) {
correct           234 test/correctness/vector_math.cpp                 printf("im5(%d, %d) = %f instead of %f\n", x, y, (double)(im5(x, y)), (double)(correct));
correct           248 test/correctness/vector_math.cpp             A correct = input(x, y) * ((A)(2));
correct           249 test/correctness/vector_math.cpp             if (im5a(x, y) != correct) {
correct           250 test/correctness/vector_math.cpp                 printf("im5a(%d, %d) = %f instead of %f\n", x, y, (double)(im5a(x, y)), (double)(correct));
correct           272 test/correctness/vector_math.cpp             int correct = y == yCoord ? 1 : 0;
correct           273 test/correctness/vector_math.cpp             if (im6(x, y) != correct) {
correct           274 test/correctness/vector_math.cpp                 printf("im6(%d, %d) = %d instead of %d\n", x, y, im6(x, y), correct);
correct           305 test/correctness/vector_math.cpp             float correct = hypotf(1.1f, (float)input(x, y));
correct           306 test/correctness/vector_math.cpp             if (!close_enough(im8(x, y), correct)) {
correct           308 test/correctness/vector_math.cpp                        x, y, (double)im8(x, y), correct);
correct           326 test/correctness/vector_math.cpp             A correct = divide(input(x, y), clamped);
correct           328 test/correctness/vector_math.cpp             if (!close_enough(im9(x, y), correct)) {
correct           332 test/correctness/vector_math.cpp                        (double)(im9(x, y)), (double)(correct));
correct           348 test/correctness/vector_math.cpp                 A correct = divide(input(x, y), (A)c);
correct           350 test/correctness/vector_math.cpp                 if (!close_enough(im10(x, y), correct)) {
correct           354 test/correctness/vector_math.cpp 			   (double)(correct));
correct           371 test/correctness/vector_math.cpp             A correct = ((x%2)==0) ? input(x/2, y) : input(x/2, y+1);
correct           372 test/correctness/vector_math.cpp             if (im11(x, y) != correct) {
correct           373 test/correctness/vector_math.cpp                 printf("im11(%d, %d) = %f instead of %f\n", x, y, (double)(im11(x, y)), (double)(correct));
correct           388 test/correctness/vector_math.cpp             A correct = input(W-1-x, H-1-y);
correct           389 test/correctness/vector_math.cpp             if (im12(x, y) != correct) {
correct           390 test/correctness/vector_math.cpp                 printf("im12(%d, %d) = %f instead of %f\n", x, y, (double)(im12(x, y)), (double)(correct));
correct           405 test/correctness/vector_math.cpp             A correct = input(x+3, y);
correct           406 test/correctness/vector_math.cpp             if (im13(x, y) != correct) {
correct           407 test/correctness/vector_math.cpp                 printf("im13(%d, %d) = %f instead of %f\n", x, y, (double)(im13(x, y)), (double)(correct));
correct           421 test/correctness/vector_math.cpp                 A correct = input(x, y);
correct           422 test/correctness/vector_math.cpp                 if (correct <= 0) correct = -correct;
correct           423 test/correctness/vector_math.cpp                 if (im14(x, y) != correct) {
correct           424 test/correctness/vector_math.cpp                     printf("im14(%d, %d) = %f instead of %f\n", x, y, (double)(im14(x, y)), (double)(correct));
correct           595 test/correctness/vector_math.cpp             A correct = (A)(lerped);
correct           596 test/correctness/vector_math.cpp             if (im21(x, y) != correct) {
correct           597 test/correctness/vector_math.cpp                 printf("lerp(%f, %f, %f) = %f instead of %f\n", a, b, w, (double)(im21(x, y)), (double)(correct));
correct           612 test/correctness/vector_math.cpp             typename with_unsigned<A>::type correct = absd((double)input(x, y), (double)input(x+1, y));
correct           613 test/correctness/vector_math.cpp             if (im22(x, y) != correct) {
correct           614 test/correctness/vector_math.cpp                 printf("im22(%d, %d) = %f instead of %f\n", x, y, (double)(im3(x, y)), (double)(correct));
correct            21 test/correctness/vectorize_varying_allocation_size.cpp         int correct = i + i*i - 20;
correct            22 test/correctness/vectorize_varying_allocation_size.cpp         if (out(i) != correct) {
correct            24 test/correctness/vectorize_varying_allocation_size.cpp                    i, out(i), correct);
correct            29 test/correctness/vectorized_load_from_vectorized_allocation.cpp                 int correct = 100 + 2*x*z;
correct            30 test/correctness/vectorized_load_from_vectorized_allocation.cpp                 if (im(x, y, z) != correct) {
correct            32 test/correctness/vectorized_load_from_vectorized_allocation.cpp                            x, y, z, im(x, y, z), correct);
correct            25 test/correctness/vectorized_reduction_bug.cpp                     int correct = (c == 3 ? 255 : 3);
correct            26 test/correctness/vectorized_reduction_bug.cpp                     if (output(x, y, c) != correct) {
correct            28 test/correctness/vectorized_reduction_bug.cpp                                x, y, c, output(x, y, c), correct);
correct            59 test/correctness/vectorized_reduction_bug.cpp                 int correct = (x != 0) ? 0 : 120*(x + y) + 120*119/2;
correct            60 test/correctness/vectorized_reduction_bug.cpp                 if (im(x, y) != correct) {
correct            62 test/correctness/vectorized_reduction_bug.cpp                            x, y, im(x, y), correct);
correct            54 test/correctness/widening_reduction.cpp                 int16_t correct = 0;
correct            57 test/correctness/widening_reduction.cpp                         correct += static_cast<int16_t>(in(x + rx, y + ry)) * kernel(rx, ry);
correct            60 test/correctness/widening_reduction.cpp                 correct = std::min(std::max(correct / 16, 0), 255);
correct            61 test/correctness/widening_reduction.cpp                 if (correct != out(x, y)) {
correct            62 test/correctness/widening_reduction.cpp                     std::cout << "out(" << x << ", " << y << ") = " << (int)out(x, y) << " instead of " << correct << "\n";
correct            96 test/correctness/widening_reduction.cpp                 int16_t correct = 0;
correct            99 test/correctness/widening_reduction.cpp                         correct += static_cast<int16_t>(in(x + rx, y + ry)) * kernel(rx, ry);
correct           100 test/correctness/widening_reduction.cpp                         correct += kernel(rx, ry);
correct           103 test/correctness/widening_reduction.cpp                 correct = std::min(std::max(correct / 16, 0), 255);
correct           104 test/correctness/widening_reduction.cpp                 if (correct != out(x, y)) {
correct           105 test/correctness/widening_reduction.cpp                     std::cout << "out(" << x << ", " << y << ") = " << (int)out(x, y) << " instead of " << correct << "\n";
correct            26 test/generator/embed_image_aottest.cpp                 float correct = input(x, y, 2 - c) * 0.5f;
correct            27 test/generator/embed_image_aottest.cpp                 if (fabs(output(x, y, c) - correct) > 0.0001f) {
correct            29 test/generator/embed_image_aottest.cpp                            correct);
correct            13 test/generator/error_codes_aottest.cpp void check(int result, int correct) {
correct            14 test/generator/error_codes_aottest.cpp     if (result != correct) {
correct            15 test/generator/error_codes_aottest.cpp         printf("The exit status was %d instead of %d\n", result, correct);
correct            40 test/generator/error_codes_aottest.cpp     int correct = halide_error_code_success;
correct            41 test/generator/error_codes_aottest.cpp     check(result, correct);
correct            46 test/generator/error_codes_aottest.cpp     correct = halide_error_code_explicit_bounds_too_small;
correct            47 test/generator/error_codes_aottest.cpp     check(result, correct);
correct            54 test/generator/error_codes_aottest.cpp     correct = halide_error_code_access_out_of_bounds;
correct            55 test/generator/error_codes_aottest.cpp     check(result, correct);
correct            67 test/generator/error_codes_aottest.cpp         correct = halide_error_code_buffer_extents_negative;
correct            68 test/generator/error_codes_aottest.cpp         check(result, correct);
correct            76 test/generator/error_codes_aottest.cpp     correct = halide_error_code_buffer_extents_too_large;
correct            77 test/generator/error_codes_aottest.cpp     check(result, correct);
correct            85 test/generator/error_codes_aottest.cpp     correct = halide_error_code_buffer_allocation_too_large;
correct            86 test/generator/error_codes_aottest.cpp     check(result, correct);
correct           100 test/generator/error_codes_aottest.cpp     correct = halide_error_code_constraint_violated;
correct           101 test/generator/error_codes_aottest.cpp     check(result, correct);
correct           106 test/generator/error_codes_aottest.cpp     correct = halide_error_code_param_too_small;
correct           107 test/generator/error_codes_aottest.cpp     check(result, correct);
correct           111 test/generator/error_codes_aottest.cpp     correct = halide_error_code_param_too_large;
correct           112 test/generator/error_codes_aottest.cpp     check(result, correct);
correct           117 test/generator/error_codes_aottest.cpp     correct = halide_error_code_buffer_argument_is_null;
correct           118 test/generator/error_codes_aottest.cpp     check(result, correct);
correct            15 test/generator/nested_externs_aottest.cpp         const float correct = 158.0f;
correct            17 test/generator/nested_externs_aottest.cpp         if (actual != correct) {
correct            19 test/generator/nested_externs_aottest.cpp                    x, y, c, actual, correct);
correct            92 test/generator/old_buffer_t_aottest.cpp             int correct = 0x01010101 * 2 + 0x02020202 * 2 + scalar_param;
correct            93 test/generator/old_buffer_t_aottest.cpp             if (result != correct) {
correct            94 test/generator/old_buffer_t_aottest.cpp                 printf("out(%d, %d) = %x instead of %x\n", x, y, (unsigned)result, (unsigned)correct);
correct            47 test/generator/pyramid_aottest.cpp                 float correct = (levels[l-1](2*x, 2*y) +
correct            52 test/generator/pyramid_aottest.cpp                 if (correct != actual) {
correct            54 test/generator/pyramid_aottest.cpp                            l, x, y, actual, correct);
correct            25 test/performance/clamped_vector_load.cpp                 uint16_t correct = input(ix1, y) * 3 + input(ix2, y);
correct            26 test/performance/clamped_vector_load.cpp                 if (output(x, y) != correct) {
correct            28 test/performance/clamped_vector_load.cpp                            x, y, output(x, y), correct);
correct            73 test/performance/const_division.cpp     Buffer<T> correct = g.realize(input.width(), num_vals);
correct            74 test/performance/const_division.cpp     double t_correct = benchmark(5, 200, [&]() { g.realize(correct); });
correct            86 test/performance/const_division.cpp             if (fast(x, y) != correct(x, y)) {
correct            90 test/performance/const_division.cpp                        (long long int)correct(x, y),
correct           175 test/performance/sort.cpp     Buffer<int> correct(N);
correct           177 test/performance/sort.cpp         correct(i) = data(i);
correct           181 test/performance/sort.cpp         std::sort(&correct(0), &correct(N));
correct           193 test/performance/sort.cpp                    correct(i), bitonic_sorted(i), merge_sorted(i));
correct           198 test/performance/sort.cpp         if (bitonic_sorted(i) != correct(i)) {
correct           199 test/performance/sort.cpp             printf("bitonic sort failed: %d -> %d instead of %d\n", i, bitonic_sorted(i), correct(i));
correct           202 test/performance/sort.cpp         if (merge_sorted(i) != correct(i)) {
correct           203 test/performance/sort.cpp             printf("merge sort failed: %d -> %d instead of %d\n", i, merge_sorted(i), correct(i));