Clang-format.

Author: mcourteaux

src/ApproximationTables.cpp

@@ -243,7 +243,6 @@ const std::vector<Approximation> table_log = {
     {OO::MULPE_MAE, {9.077671e-17, 2.980232e-08, 2.000e+00}, {1.185618e-17, 7.323494e-09, 7.284e-01}, {+9.999999968426e-01, -5.000010022894e-01, +3.333352677374e-01, -2.499137788257e-01, +1.997704915474e-01, -1.685521799690e-01, +1.500791323679e-01, -1.190706400136e-01, +5.196620089570e-02}},
 };
 
-
 // clang-format on
 }  // namespace
 

src/IROperator.cpp

@@ -1400,16 +1400,15 @@ Expr fast_sin_cos_v2(const Expr &x_full, bool is_sin, ApproximationPrecision pre
     Expr k = cast<int>(k_real);
     Expr k_mod4 = k % 4;
     Expr sin_usecos = is_sin ? ((k_mod4 == 1) || (k_mod4 == 3)) : ((k_mod4 == 0) || (k_mod4 == 2));
-    //sin_usecos = !sin_usecos;
+    // sin_usecos = !sin_usecos;
     Expr flip_sign = is_sin ? (k_mod4 > 1) : ((k_mod4 == 1) || (k_mod4 == 2));
 
     // Reduce the angle modulo pi/2: i.e., to the angle within the quadrant.
     Expr x = x_full - k_real * constant(type, PI_OVER_TWO);
     x = select(sin_usecos, constant(type, PI_OVER_TWO) - x, x);
 
-
     const Internal::Approximation *approx = Internal::best_sin_approximation(precision, type);
-    //const Internal::Approximation *approx = Internal::best_cos_approximation(precision);
+    // const Internal::Approximation *approx = Internal::best_cos_approximation(precision);
     const std::vector<double> &c = approx->coefficients;
     Expr x2 = x * x;
     Expr result = constant(type, c.back());
@@ -1424,17 +1423,17 @@ Expr fast_sin_cos_v2(const Expr &x_full, bool is_sin, ApproximationPrecision pre
 }  // namespace
 
 Expr fast_sin(const Expr &x, ApproximationPrecision precision) {
-    //return fast_sin_cos(x, true);
+    // return fast_sin_cos(x, true);
     Expr native_is_fast = target_has_feature(Target::Vulkan);
     return select(native_is_fast && precision.allow_native_when_faster,
-            sin(x), fast_sin_cos_v2(x, true, precision));
+                  sin(x), fast_sin_cos_v2(x, true, precision));
 }
 
 Expr fast_cos(const Expr &x, ApproximationPrecision precision) {
-    //return fast_sin_cos(x, false);
+    // return fast_sin_cos(x, false);
     Expr native_is_fast = target_has_feature(Target::Vulkan);
     return select(native_is_fast && precision.allow_native_when_faster,
-            cos(x), fast_sin_cos_v2(x, false, precision));
+                  cos(x), fast_sin_cos_v2(x, false, precision));
 }
 
 // A vectorizable atan and atan2 implementation.

src/IROperator.h

@@ -1013,7 +1013,6 @@ Expr fast_sin(const Expr &x, ApproximationPrecision precision = {ApproximationPr
 Expr fast_cos(const Expr &x, ApproximationPrecision precision = {ApproximationPrecision::MULPE, 0, 1e-5});
 // @}
 
-
 /** Fast vectorizable approximations for arctan and arctan2 for Float(32).
  *
  * Desired precision can be specified as either a maximum absolute error (MAE) or

test/correctness/fast_function_approximations.cpp

@@ -43,8 +43,8 @@ struct FunctionToTest {
     TestRange2D extended;
     std::function<Expr(Expr x, Expr y)> make_reference;
     std::function<Expr(Expr x, Expr y, Halide::ApproximationPrecision)> make_approximation;
-    int max_mulpe_precise{0}; // max MULPE allowed when MAE query was <= 1e-6
-    int max_mulpe_extended{0}; // max MULPE allowed when MAE query was <= 1e-6
+    int max_mulpe_precise{0};   // max MULPE allowed when MAE query was <= 1e-6
+    int max_mulpe_extended{0};  // max MULPE allowed when MAE query was <= 1e-6
     int test_bits{0xff};
 } functions_to_test[] = {
     // clang-format off
@@ -141,7 +141,6 @@ struct PrecisionToTest {
     {{ApproximationPrecision::MULPE_MAE, 0, 5e-7}, "MULPE+MAE"},
 };
 
-
 int main(int argc, char **argv) {
     Target target = get_jit_target_from_environment();
     setlocale(LC_NUMERIC, "");
@@ -166,17 +165,17 @@ int main(int argc, char **argv) {
         for (const std::pair<TestRange2D, std::string> &test_range_and_name : ranges) {
             TestRange2D range = test_range_and_name.first;
             printf("Testing fast_%s on its %s range ([%f, %f], [%f, %f])...\n", ftt.name.c_str(), test_range_and_name.second.c_str(),
-                    range.x.l, range.x.u, range.y.l, range.y.u);
+                   range.x.l, range.x.u, range.y.l, range.y.u);
             // Reference:
             Expr arg_x = range.x.l * (1.0f - t0) + range.x.u * t0;
             Expr arg_y = range.y.l * (1.0f - t1) + range.y.u * t1;
             Func ref_func{ftt.name + "_ref"};
             ref_func(x, y) = ftt.make_reference(arg_x, arg_y);
-            ref_func.realize(out_ref); // No schedule: scalar evaluation using libm calls on CPU.
+            ref_func.realize(out_ref);  // No schedule: scalar evaluation using libm calls on CPU.
             out_ref.copy_to_host();
             for (const PrecisionToTest &test : precisions_to_test) {
                 Halide::ApproximationPrecision prec = test.precision;
-                prec.allow_native_when_faster = false; // We want to actually validate our approximation.
+                prec.allow_native_when_faster = false;  // We want to actually validate our approximation.
 
                 Func approx_func{ftt.name + "_approx"};
                 approx_func(x, y) = ftt.make_approximation(arg_x, arg_y, prec);
@@ -211,8 +210,8 @@ int main(int argc, char **argv) {
                 }
 
                 printf("    fast_%s  Approx[%s-optimized, TargetMAE=%.0e] | MaxAbsError: %.4e | MaxULPError: %'14d | MaxMantissaError: %2d",
-                        ftt.name.c_str(), test.objective.c_str(), prec.constraint_max_absolute_error,
-                        max_absolute_error, max_ulp_error, max_mantissa_error);
+                       ftt.name.c_str(), test.objective.c_str(), prec.constraint_max_absolute_error,
+                       max_absolute_error, max_ulp_error, max_mantissa_error);
 
                 if (test_range_and_name.second == "precise") {
                     if ((ftt.test_bits & VALIDATE_MAE_ON_PRECISE)) {
@@ -261,4 +260,3 @@ int main(int argc, char **argv) {
     printf("Passed %d / %d accuracy tests.\n", num_tests_passed, num_tests);
     printf("Success!\n");
 }
-

test/correctness/fast_trigonometric.cpp

@@ -30,11 +30,11 @@ int main(int argc, char **argv) {
         const float cos_x_ref = cos(x);
         if (std::abs(sin_x_ref - sin_x) > 1e-5) {
             fprintf(stderr, "fast_sin(%.6f) = %.20f not equal to %.20f\n", x, sin_x, sin_x_ref);
-            //exit(1);
+            // exit(1);
         }
         if (std::abs(cos_x_ref - cos_x) > 1e-5) {
             fprintf(stderr, "fast_cos(%.6f) = %.20f not equal to %.20f\n", x, cos_x, cos_x_ref);
-            //exit(1);
+            // exit(1);
         }
     }
     printf("Success!\n");

test/performance/fast_function_approximations.cpp

@@ -152,9 +152,9 @@ int main(int argc, char **argv) {
 
         // Print results for this function
         printf("      %s           : %9.5f ns per evaluation  [per invokation: %6.3f ms]\n",
-                ftt.name.c_str(),
-                pipeline_time_ref * pipeline_time_to_ns_per_evaluation,
-                pipeline_time_ref * 1e3);
+               ftt.name.c_str(),
+               pipeline_time_ref * pipeline_time_to_ns_per_evaluation,
+               pipeline_time_ref * 1e3);
 
         for (PrecisionToTest &precision : precisions_to_test) {
             double approx_pipeline_time;
@@ -163,7 +163,7 @@ int main(int argc, char **argv) {
             {
                 Func approx_func{ftt.name + "_approx"};
                 Halide::ApproximationPrecision prec = precision.precision;
-                prec.allow_native_when_faster = false; // Always test the actual tabular functions.
+                prec.allow_native_when_faster = false;  // Always test the actual tabular functions.
                 approx_func(x, y) = sum(ftt.make_approximation(arg_x, arg_y, arg_z, prec));
                 schedule(approx_func);
                 approx_func.compile_jit();
@@ -180,14 +180,13 @@ int main(int argc, char **argv) {
             {
                 Func approx_func{ftt.name + "_approx_maybe_native"};
                 Halide::ApproximationPrecision prec = precision.precision;
-                prec.allow_native_when_faster = true; // Now make sure it's always at least as fast!
+                prec.allow_native_when_faster = true;  // Now make sure it's always at least as fast!
                 approx_func(x, y) = sum(ftt.make_approximation(arg_x, arg_y, arg_z, prec));
                 schedule(approx_func);
                 approx_func.compile_jit();
                 approx_maybe_native_pipeline_time = benchmark([&]() { approx_func.realize(buffer_out); buffer_out.device_sync(); }, bcfg);
             }
 
-
             // Check for speedup
             bool should_be_faster = true;
             for (Target::Feature f : ftt.not_faster_on) {
@@ -197,7 +196,6 @@ int main(int argc, char **argv) {
             }
             if (should_be_faster) num_tests++;
 
-
             printf(" [force_approx");
             if (pipeline_time_ref < approx_pipeline_time * 0.90) {
                 printf("   %6.1f%% slower", -100.0f * (1.0f - approx_pipeline_time / pipeline_time_ref));
@@ -208,11 +206,11 @@ int main(int argc, char **argv) {
                 }
             } else if (pipeline_time_ref < approx_pipeline_time * 1.10) {
                 printf("   equally fast (%+5.1f%% faster)",
-                        100.0f * (1.0f - approx_pipeline_time / pipeline_time_ref));
+                       100.0f * (1.0f - approx_pipeline_time / pipeline_time_ref));
                 if (should_be_faster) num_passed++;
             } else {
                 printf("   %4.1f%% faster",
-                        100.0f * (1.0f - approx_pipeline_time / pipeline_time_ref));
+                       100.0f * (1.0f - approx_pipeline_time / pipeline_time_ref));
                 if (should_be_faster) num_passed++;
             }
             printf("]");