[Math] Don't use scalar fallback for types like ROOT::Double_v

The fallback to the vector types being defined as scalars if `std::simd`
is not available is confusing, and doesn't help anyway because the code
for scalar types and `std::simd` usage has to look different.

Author: guitargeek

hist/hist/inc/TF1.h

@@ -717,34 +717,33 @@ namespace ROOT {
       template<class Func>
       void TF1Builder<Func>::Build(TF1 *f, Func func)
       {
+#ifdef R__HAS_STD_SIMD
          // check if vector interface is supported by Func
          if constexpr(std::is_invocable_r_v<Double_v, Func, Double_v*, double *>) {
-            // if ROOT was not built with std::experimental::simd support, Double_v is just an alias for the scalar
-            // double
-            f->fType = std::is_same<Double_v, double>::value ? TF1::EFType::kTemplScalar : TF1::EFType::kTemplVec;
+            f->fType = TF1::EFType::kTemplVec;
             f->fFunctor.reset(new TF1::TF1FunctorPointerImpl(ROOT::Math::ParamFunctorTempl<Double_v>(func)));
-         } else {
-            f->fType = TF1::EFType::kTemplScalar;
-            f->fFunctor.reset(new TF1::TF1FunctorPointerImpl(ROOT::Math::ParamFunctorTempl<double>(func)));
+            f->fParams = std::make_unique<TF1Parameters>(f->fNpar);
          }
+#endif
 
+         f->fType = TF1::EFType::kTemplScalar;
+         f->fFunctor.reset(new TF1::TF1FunctorPointerImpl(ROOT::Math::ParamFunctorTempl<double>(func)));
          f->fParams = std::make_unique<TF1Parameters>(f->fNpar);
       }
 
       template<class Func>
       void TF1Builder<Func *>::Build(TF1 *f, Func *func)
       {
+#ifdef R__HAS_STD_SIMD
          // check if vector interface is supported by Func
          if constexpr(std::is_invocable_r_v<Double_v, Func, Double_v*, double *>) {
-            // if ROOT was not built with std::experimental::simd support, Double_v is just an alias for the scalar
-            // double
-            f->fType = std::is_same<Double_v, double>::value ? TF1::EFType::kTemplScalar : TF1::EFType::kTemplVec;
+            f->fType = TF1::EFType::kTemplVec;
             f->fFunctor.reset(new TF1::TF1FunctorPointerImpl(ROOT::Math::ParamFunctorTempl<Double_v>(func)));
-         } else {
-            f->fType = TF1::EFType::kTemplScalar;
-            f->fFunctor.reset(new TF1::TF1FunctorPointerImpl(ROOT::Math::ParamFunctorTempl<double>(func)));
+            f->fParams = std::make_unique<TF1Parameters>(f->fNpar);
          }
-
+#endif
+         f->fType = TF1::EFType::kTemplScalar;
+         f->fFunctor.reset(new TF1::TF1FunctorPointerImpl(ROOT::Math::ParamFunctorTempl<double>(func)));
          f->fParams = std::make_unique<TF1Parameters>(f->fNpar);
       }
 

math/mathcore/inc/Math/Types.h

@@ -18,6 +18,7 @@ using SIMDTag = std::experimental::simd_abi::native<T>;
 
 } // namespace Internal
 
+// FIXME: Should we introduce Int32_t and UInt32_t in RtypesCore.h?
 using Float_v = std::experimental::simd<Float_t, Internal::SIMDTag<Float_t>>;
 using Double_v = std::experimental::simd<Double_t, Internal::SIMDTag<Double_t>>;
 using Int_v = std::experimental::simd<Int_t, Internal::SIMDTag<Int_t>>;
@@ -27,18 +28,6 @@ using UInt32_v = std::experimental::simd<UInt_t, Internal::SIMDTag<UInt_t>>;
 
 } // namespace ROOT
 
-#else // R__HAS_STD_SIMD
-
-// We do not have explicit vectorisation support enabled. Fall back to regular ROOT types.
-
-namespace ROOT {
-   using Float_v  = Float_t;
-   using Double_v = Double_t;
-   using Int_v    = Int_t;
-   using Int32_v  = Int_t; // FIXME: Should we introduce Int32_t in RtypesCore.h?
-   using UInt_v   = UInt_t;
-   using UInt32_v = UInt_t; // FIXME: Should we introduce UInt32_t in RtypesCore.h?
-}
 #endif
 
 #endif // ROOT_Math_VecTypes